2019-01-07 06:44:54 -06:00
|
|
|
//! This module is concerned with finding methods that a given type provides.
|
|
|
|
//! For details about how this works in rustc, see the method lookup page in the
|
|
|
|
//! [rustc guide](https://rust-lang.github.io/rustc-guide/method-lookup.html)
|
2022-09-26 06:00:29 -05:00
|
|
|
//! and the corresponding code mostly in rustc_hir_analysis/check/method/probe.rs.
|
2022-12-04 13:12:11 -06:00
|
|
|
use std::{ops::ControlFlow, sync::Arc};
|
2019-01-07 06:44:54 -06:00
|
|
|
|
2021-06-01 14:33:14 -05:00
|
|
|
use base_db::{CrateId, Edition};
|
2023-01-31 10:53:38 -06:00
|
|
|
use chalk_ir::{cast::Cast, Mutability, TyKind, UniverseIndex};
|
2019-11-26 06:27:33 -06:00
|
|
|
use hir_def::{
|
2023-01-21 10:29:07 -06:00
|
|
|
data::ImplData, item_scope::ItemScope, lang_item::LangItem, nameres::DefMap, AssocItemId,
|
|
|
|
BlockId, ConstId, FunctionId, HasModule, ImplId, ItemContainerId, Lookup, ModuleDefId,
|
|
|
|
ModuleId, TraitId,
|
2019-11-26 06:27:33 -06:00
|
|
|
};
|
2019-11-26 13:26:47 -06:00
|
|
|
use hir_expand::name::Name;
|
2020-01-14 07:11:07 -06:00
|
|
|
use rustc_hash::{FxHashMap, FxHashSet};
|
2022-12-04 13:12:11 -06:00
|
|
|
use smallvec::{smallvec, SmallVec};
|
2021-11-10 10:33:35 -06:00
|
|
|
use stdx::never;
|
2019-01-07 06:44:54 -06:00
|
|
|
|
2019-01-12 14:27:35 -06:00
|
|
|
use crate::{
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
autoderef::{self, AutoderefKind},
|
2020-07-11 12:12:10 -05:00
|
|
|
db::HirDatabase,
|
2023-01-20 16:09:35 -06:00
|
|
|
from_chalk_trait_id, from_foreign_def_id,
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
infer::{unify::InferenceTable, Adjust, Adjustment, AutoBorrow, OverloadedDeref, PointerCast},
|
2022-04-02 08:32:40 -05:00
|
|
|
primitive::{FloatTy, IntTy, UintTy},
|
2022-11-01 04:31:31 -05:00
|
|
|
static_lifetime, to_chalk_trait_id,
|
2020-07-11 12:12:10 -05:00
|
|
|
utils::all_super_traits,
|
2022-03-17 06:39:42 -05:00
|
|
|
AdtId, Canonical, CanonicalVarKinds, DebruijnIndex, ForeignDefId, InEnvironment, Interner,
|
2023-01-31 10:53:38 -06:00
|
|
|
Scalar, Substitution, TraitEnvironment, TraitRef, TraitRefExt, Ty, TyBuilder, TyExt,
|
2019-01-12 14:27:35 -06:00
|
|
|
};
|
2019-01-07 06:44:54 -06:00
|
|
|
|
|
|
|
/// This is used as a key for indexing impls.
|
|
|
|
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
|
|
|
|
pub enum TyFingerprint {
|
2021-04-07 12:35:24 -05:00
|
|
|
// These are lang item impls:
|
2021-02-28 12:13:37 -06:00
|
|
|
Str,
|
|
|
|
Slice,
|
|
|
|
Array,
|
|
|
|
Never,
|
|
|
|
RawPtr(Mutability),
|
|
|
|
Scalar(Scalar),
|
2021-04-07 12:35:24 -05:00
|
|
|
// These can have user-defined impls:
|
2021-03-01 14:57:39 -06:00
|
|
|
Adt(hir_def::AdtId),
|
2021-02-08 12:13:54 -06:00
|
|
|
Dyn(TraitId),
|
2021-03-13 10:23:19 -06:00
|
|
|
ForeignType(ForeignDefId),
|
2021-04-07 12:35:24 -05:00
|
|
|
// These only exist for trait impls
|
|
|
|
Unit,
|
|
|
|
Unnameable,
|
|
|
|
Function(u32),
|
2019-01-07 06:44:54 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
impl TyFingerprint {
|
2021-04-07 12:35:24 -05:00
|
|
|
/// Creates a TyFingerprint for looking up an inherent impl. Only certain
|
|
|
|
/// types can have inherent impls: if we have some `struct S`, we can have
|
|
|
|
/// an `impl S`, but not `impl &S`. Hence, this will return `None` for
|
|
|
|
/// reference types and such.
|
|
|
|
pub fn for_inherent_impl(ty: &Ty) -> Option<TyFingerprint> {
|
2021-12-19 10:58:39 -06:00
|
|
|
let fp = match ty.kind(Interner) {
|
2021-03-13 07:44:51 -06:00
|
|
|
TyKind::Str => TyFingerprint::Str,
|
|
|
|
TyKind::Never => TyFingerprint::Never,
|
|
|
|
TyKind::Slice(..) => TyFingerprint::Slice,
|
|
|
|
TyKind::Array(..) => TyFingerprint::Array,
|
2021-04-05 15:23:16 -05:00
|
|
|
TyKind::Scalar(scalar) => TyFingerprint::Scalar(*scalar),
|
|
|
|
TyKind::Adt(AdtId(adt), _) => TyFingerprint::Adt(*adt),
|
|
|
|
TyKind::Raw(mutability, ..) => TyFingerprint::RawPtr(*mutability),
|
|
|
|
TyKind::Foreign(alias_id, ..) => TyFingerprint::ForeignType(*alias_id),
|
2021-06-12 22:59:36 -05:00
|
|
|
TyKind::Dyn(_) => ty.dyn_trait().map(TyFingerprint::Dyn)?,
|
2021-02-28 12:13:37 -06:00
|
|
|
_ => return None,
|
|
|
|
};
|
|
|
|
Some(fp)
|
2019-01-07 06:44:54 -06:00
|
|
|
}
|
2021-04-07 12:35:24 -05:00
|
|
|
|
|
|
|
/// Creates a TyFingerprint for looking up a trait impl.
|
|
|
|
pub fn for_trait_impl(ty: &Ty) -> Option<TyFingerprint> {
|
2021-12-19 10:58:39 -06:00
|
|
|
let fp = match ty.kind(Interner) {
|
2021-04-07 12:35:24 -05:00
|
|
|
TyKind::Str => TyFingerprint::Str,
|
|
|
|
TyKind::Never => TyFingerprint::Never,
|
|
|
|
TyKind::Slice(..) => TyFingerprint::Slice,
|
|
|
|
TyKind::Array(..) => TyFingerprint::Array,
|
|
|
|
TyKind::Scalar(scalar) => TyFingerprint::Scalar(*scalar),
|
|
|
|
TyKind::Adt(AdtId(adt), _) => TyFingerprint::Adt(*adt),
|
|
|
|
TyKind::Raw(mutability, ..) => TyFingerprint::RawPtr(*mutability),
|
|
|
|
TyKind::Foreign(alias_id, ..) => TyFingerprint::ForeignType(*alias_id),
|
2021-06-12 22:59:36 -05:00
|
|
|
TyKind::Dyn(_) => ty.dyn_trait().map(TyFingerprint::Dyn)?,
|
2021-04-07 12:35:24 -05:00
|
|
|
TyKind::Ref(_, _, ty) => return TyFingerprint::for_trait_impl(ty),
|
|
|
|
TyKind::Tuple(_, subst) => {
|
2021-12-19 10:58:39 -06:00
|
|
|
let first_ty = subst.interned().get(0).map(|arg| arg.assert_ty_ref(Interner));
|
2021-10-03 07:53:01 -05:00
|
|
|
match first_ty {
|
|
|
|
Some(ty) => return TyFingerprint::for_trait_impl(ty),
|
|
|
|
None => TyFingerprint::Unit,
|
2021-04-07 12:35:24 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
TyKind::AssociatedType(_, _)
|
|
|
|
| TyKind::OpaqueType(_, _)
|
|
|
|
| TyKind::FnDef(_, _)
|
|
|
|
| TyKind::Closure(_, _)
|
|
|
|
| TyKind::Generator(..)
|
|
|
|
| TyKind::GeneratorWitness(..) => TyFingerprint::Unnameable,
|
|
|
|
TyKind::Function(fn_ptr) => {
|
2021-12-19 10:58:39 -06:00
|
|
|
TyFingerprint::Function(fn_ptr.substitution.0.len(Interner) as u32)
|
2021-04-07 12:35:24 -05:00
|
|
|
}
|
|
|
|
TyKind::Alias(_)
|
|
|
|
| TyKind::Placeholder(_)
|
|
|
|
| TyKind::BoundVar(_)
|
|
|
|
| TyKind::InferenceVar(_, _)
|
|
|
|
| TyKind::Error => return None,
|
|
|
|
};
|
|
|
|
Some(fp)
|
|
|
|
}
|
2019-01-07 06:44:54 -06:00
|
|
|
}
|
|
|
|
|
2020-07-11 12:12:10 -05:00
|
|
|
pub(crate) const ALL_INT_FPS: [TyFingerprint; 12] = [
|
2021-02-28 12:13:37 -06:00
|
|
|
TyFingerprint::Scalar(Scalar::Int(IntTy::I8)),
|
|
|
|
TyFingerprint::Scalar(Scalar::Int(IntTy::I16)),
|
|
|
|
TyFingerprint::Scalar(Scalar::Int(IntTy::I32)),
|
|
|
|
TyFingerprint::Scalar(Scalar::Int(IntTy::I64)),
|
|
|
|
TyFingerprint::Scalar(Scalar::Int(IntTy::I128)),
|
|
|
|
TyFingerprint::Scalar(Scalar::Int(IntTy::Isize)),
|
|
|
|
TyFingerprint::Scalar(Scalar::Uint(UintTy::U8)),
|
|
|
|
TyFingerprint::Scalar(Scalar::Uint(UintTy::U16)),
|
|
|
|
TyFingerprint::Scalar(Scalar::Uint(UintTy::U32)),
|
|
|
|
TyFingerprint::Scalar(Scalar::Uint(UintTy::U64)),
|
|
|
|
TyFingerprint::Scalar(Scalar::Uint(UintTy::U128)),
|
|
|
|
TyFingerprint::Scalar(Scalar::Uint(UintTy::Usize)),
|
2020-07-11 12:12:10 -05:00
|
|
|
];
|
|
|
|
|
|
|
|
pub(crate) const ALL_FLOAT_FPS: [TyFingerprint; 2] = [
|
2021-02-28 12:13:37 -06:00
|
|
|
TyFingerprint::Scalar(Scalar::Float(FloatTy::F32)),
|
|
|
|
TyFingerprint::Scalar(Scalar::Float(FloatTy::F64)),
|
2020-07-11 12:12:10 -05:00
|
|
|
];
|
|
|
|
|
2020-07-01 10:15:20 -05:00
|
|
|
/// Trait impls defined or available in some crate.
|
|
|
|
#[derive(Debug, Eq, PartialEq)]
|
|
|
|
pub struct TraitImpls {
|
|
|
|
// If the `Option<TyFingerprint>` is `None`, the impl may apply to any self type.
|
|
|
|
map: FxHashMap<TraitId, FxHashMap<Option<TyFingerprint>, Vec<ImplId>>>,
|
2019-01-07 06:44:54 -06:00
|
|
|
}
|
|
|
|
|
2020-07-01 10:15:20 -05:00
|
|
|
impl TraitImpls {
|
|
|
|
pub(crate) fn trait_impls_in_crate_query(db: &dyn HirDatabase, krate: CrateId) -> Arc<Self> {
|
2022-07-21 03:17:57 -05:00
|
|
|
let _p = profile::span("trait_impls_in_crate_query").detail(|| format!("{krate:?}"));
|
2020-07-01 10:15:20 -05:00
|
|
|
let mut impls = Self { map: FxHashMap::default() };
|
2019-11-26 06:27:33 -06:00
|
|
|
|
2020-07-01 10:15:20 -05:00
|
|
|
let crate_def_map = db.crate_def_map(krate);
|
2021-06-13 06:00:34 -05:00
|
|
|
impls.collect_def_map(db, &crate_def_map);
|
2021-12-09 11:39:46 -06:00
|
|
|
impls.shrink_to_fit();
|
2021-04-06 20:33:22 -05:00
|
|
|
|
2021-09-03 09:00:50 -05:00
|
|
|
Arc::new(impls)
|
2021-06-13 06:00:34 -05:00
|
|
|
}
|
2021-04-06 20:33:22 -05:00
|
|
|
|
2021-06-13 06:00:34 -05:00
|
|
|
pub(crate) fn trait_impls_in_block_query(
|
|
|
|
db: &dyn HirDatabase,
|
|
|
|
block: BlockId,
|
|
|
|
) -> Option<Arc<Self>> {
|
|
|
|
let _p = profile::span("trait_impls_in_block_query");
|
|
|
|
let mut impls = Self { map: FxHashMap::default() };
|
|
|
|
|
|
|
|
let block_def_map = db.block_def_map(block)?;
|
|
|
|
impls.collect_def_map(db, &block_def_map);
|
2021-12-09 11:39:46 -06:00
|
|
|
impls.shrink_to_fit();
|
2021-06-13 06:00:34 -05:00
|
|
|
|
2021-09-03 09:00:50 -05:00
|
|
|
Some(Arc::new(impls))
|
2021-06-13 06:00:34 -05:00
|
|
|
}
|
|
|
|
|
2021-12-09 11:39:46 -06:00
|
|
|
pub(crate) fn trait_impls_in_deps_query(db: &dyn HirDatabase, krate: CrateId) -> Arc<Self> {
|
2022-07-21 03:17:57 -05:00
|
|
|
let _p = profile::span("trait_impls_in_deps_query").detail(|| format!("{krate:?}"));
|
2021-12-09 11:39:46 -06:00
|
|
|
let crate_graph = db.crate_graph();
|
|
|
|
let mut res = Self { map: FxHashMap::default() };
|
|
|
|
|
|
|
|
for krate in crate_graph.transitive_deps(krate) {
|
|
|
|
res.merge(&db.trait_impls_in_crate(krate));
|
|
|
|
}
|
|
|
|
res.shrink_to_fit();
|
|
|
|
|
|
|
|
Arc::new(res)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn shrink_to_fit(&mut self) {
|
|
|
|
self.map.shrink_to_fit();
|
|
|
|
self.map.values_mut().for_each(|map| {
|
|
|
|
map.shrink_to_fit();
|
|
|
|
map.values_mut().for_each(Vec::shrink_to_fit);
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2021-06-13 06:00:34 -05:00
|
|
|
fn collect_def_map(&mut self, db: &dyn HirDatabase, def_map: &DefMap) {
|
|
|
|
for (_module_id, module_data) in def_map.modules() {
|
|
|
|
for impl_id in module_data.scope.impls() {
|
|
|
|
let target_trait = match db.impl_trait(impl_id) {
|
|
|
|
Some(tr) => tr.skip_binders().hir_trait_id(),
|
|
|
|
None => continue,
|
|
|
|
};
|
|
|
|
let self_ty = db.impl_self_ty(impl_id);
|
|
|
|
let self_ty_fp = TyFingerprint::for_trait_impl(self_ty.skip_binders());
|
|
|
|
self.map
|
|
|
|
.entry(target_trait)
|
|
|
|
.or_default()
|
|
|
|
.entry(self_ty_fp)
|
|
|
|
.or_default()
|
|
|
|
.push(impl_id);
|
|
|
|
}
|
2021-04-06 20:33:22 -05:00
|
|
|
|
2021-06-13 06:00:34 -05:00
|
|
|
// To better support custom derives, collect impls in all unnamed const items.
|
|
|
|
// const _: () = { ... };
|
2021-12-08 08:44:52 -06:00
|
|
|
for konst in collect_unnamed_consts(db, &module_data.scope) {
|
2021-06-13 06:00:34 -05:00
|
|
|
let body = db.body(konst.into());
|
|
|
|
for (_, block_def_map) in body.blocks(db.upcast()) {
|
|
|
|
self.collect_def_map(db, &block_def_map);
|
2021-04-06 20:33:22 -05:00
|
|
|
}
|
2020-07-01 10:15:20 -05:00
|
|
|
}
|
|
|
|
}
|
2020-06-18 18:29:34 -05:00
|
|
|
}
|
|
|
|
|
2020-06-19 17:36:02 -05:00
|
|
|
fn merge(&mut self, other: &Self) {
|
2020-07-01 10:15:20 -05:00
|
|
|
for (trait_, other_map) in &other.map {
|
|
|
|
let map = self.map.entry(*trait_).or_default();
|
2020-06-19 17:36:02 -05:00
|
|
|
for (fp, impls) in other_map {
|
2022-07-21 03:17:57 -05:00
|
|
|
map.entry(*fp).or_default().extend(impls);
|
2020-06-19 17:36:02 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-03-15 07:49:21 -05:00
|
|
|
/// Queries all trait impls for the given type.
|
2021-04-07 12:35:24 -05:00
|
|
|
pub fn for_self_ty_without_blanket_impls(
|
|
|
|
&self,
|
|
|
|
fp: TyFingerprint,
|
|
|
|
) -> impl Iterator<Item = ImplId> + '_ {
|
2021-03-15 07:49:21 -05:00
|
|
|
self.map
|
|
|
|
.values()
|
2021-04-07 12:35:24 -05:00
|
|
|
.flat_map(move |impls| impls.get(&Some(fp)).into_iter())
|
2021-03-15 07:49:21 -05:00
|
|
|
.flat_map(|it| it.iter().copied())
|
|
|
|
}
|
|
|
|
|
2020-07-01 10:15:20 -05:00
|
|
|
/// Queries all impls of the given trait.
|
|
|
|
pub fn for_trait(&self, trait_: TraitId) -> impl Iterator<Item = ImplId> + '_ {
|
|
|
|
self.map
|
|
|
|
.get(&trait_)
|
2020-04-11 06:11:33 -05:00
|
|
|
.into_iter()
|
2020-07-01 10:15:20 -05:00
|
|
|
.flat_map(|map| map.values().flat_map(|v| v.iter().copied()))
|
2020-04-11 06:11:33 -05:00
|
|
|
}
|
|
|
|
|
2020-07-01 10:15:20 -05:00
|
|
|
/// Queries all impls of `trait_` that may apply to `self_ty`.
|
|
|
|
pub fn for_trait_and_self_ty(
|
2020-04-11 06:11:33 -05:00
|
|
|
&self,
|
2020-07-01 10:15:20 -05:00
|
|
|
trait_: TraitId,
|
|
|
|
self_ty: TyFingerprint,
|
2020-04-11 06:11:33 -05:00
|
|
|
) -> impl Iterator<Item = ImplId> + '_ {
|
2020-07-01 10:15:20 -05:00
|
|
|
self.map
|
|
|
|
.get(&trait_)
|
2020-04-11 06:11:33 -05:00
|
|
|
.into_iter()
|
2022-06-15 10:13:15 -05:00
|
|
|
.flat_map(move |map| map.get(&Some(self_ty)).into_iter().chain(map.get(&None)))
|
2020-07-01 10:15:20 -05:00
|
|
|
.flat_map(|v| v.iter().copied())
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn all_impls(&self) -> impl Iterator<Item = ImplId> + '_ {
|
|
|
|
self.map.values().flat_map(|map| map.values().flat_map(|v| v.iter().copied()))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Inherent impls defined in some crate.
|
|
|
|
///
|
|
|
|
/// Inherent impls can only be defined in the crate that also defines the self type of the impl
|
|
|
|
/// (note that some primitives are considered to be defined by both libcore and liballoc).
|
|
|
|
///
|
|
|
|
/// This makes inherent impl lookup easier than trait impl lookup since we only have to consider a
|
|
|
|
/// single crate.
|
|
|
|
#[derive(Debug, Eq, PartialEq)]
|
|
|
|
pub struct InherentImpls {
|
|
|
|
map: FxHashMap<TyFingerprint, Vec<ImplId>>,
|
2023-01-20 16:09:35 -06:00
|
|
|
invalid_impls: Vec<ImplId>,
|
2020-07-01 10:15:20 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
impl InherentImpls {
|
|
|
|
pub(crate) fn inherent_impls_in_crate_query(db: &dyn HirDatabase, krate: CrateId) -> Arc<Self> {
|
2023-01-20 16:09:35 -06:00
|
|
|
let mut impls = Self { map: FxHashMap::default(), invalid_impls: Vec::default() };
|
2020-07-01 10:15:20 -05:00
|
|
|
|
|
|
|
let crate_def_map = db.crate_def_map(krate);
|
2021-11-09 04:13:42 -06:00
|
|
|
impls.collect_def_map(db, &crate_def_map);
|
2021-12-09 11:39:46 -06:00
|
|
|
impls.shrink_to_fit();
|
2021-04-18 18:06:26 -05:00
|
|
|
|
2022-03-12 07:56:26 -06:00
|
|
|
Arc::new(impls)
|
2021-11-09 04:13:42 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn inherent_impls_in_block_query(
|
|
|
|
db: &dyn HirDatabase,
|
|
|
|
block: BlockId,
|
|
|
|
) -> Option<Arc<Self>> {
|
2023-01-20 16:09:35 -06:00
|
|
|
let mut impls = Self { map: FxHashMap::default(), invalid_impls: Vec::default() };
|
2021-11-09 04:13:42 -06:00
|
|
|
if let Some(block_def_map) = db.block_def_map(block) {
|
|
|
|
impls.collect_def_map(db, &block_def_map);
|
2021-12-09 11:39:46 -06:00
|
|
|
impls.shrink_to_fit();
|
2021-11-09 04:13:42 -06:00
|
|
|
return Some(Arc::new(impls));
|
|
|
|
}
|
2022-03-12 07:56:26 -06:00
|
|
|
None
|
2021-11-09 04:13:42 -06:00
|
|
|
}
|
|
|
|
|
2021-12-09 11:39:46 -06:00
|
|
|
fn shrink_to_fit(&mut self) {
|
|
|
|
self.map.values_mut().for_each(Vec::shrink_to_fit);
|
|
|
|
self.map.shrink_to_fit();
|
|
|
|
}
|
|
|
|
|
2021-11-09 04:13:42 -06:00
|
|
|
fn collect_def_map(&mut self, db: &dyn HirDatabase, def_map: &DefMap) {
|
|
|
|
for (_module_id, module_data) in def_map.modules() {
|
|
|
|
for impl_id in module_data.scope.impls() {
|
|
|
|
let data = db.impl_data(impl_id);
|
|
|
|
if data.target_trait.is_some() {
|
|
|
|
continue;
|
|
|
|
}
|
2021-04-18 18:06:26 -05:00
|
|
|
|
2021-11-09 04:13:42 -06:00
|
|
|
let self_ty = db.impl_self_ty(impl_id);
|
2023-01-20 16:09:35 -06:00
|
|
|
let self_ty = self_ty.skip_binders();
|
|
|
|
|
|
|
|
match is_inherent_impl_coherent(db, def_map, &data, self_ty) {
|
|
|
|
true => {
|
|
|
|
// `fp` should only be `None` in error cases (either erroneous code or incomplete name resolution)
|
|
|
|
if let Some(fp) = TyFingerprint::for_inherent_impl(self_ty) {
|
|
|
|
self.map.entry(fp).or_default().push(impl_id);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
false => self.invalid_impls.push(impl_id),
|
2020-07-01 10:15:20 -05:00
|
|
|
}
|
2021-11-09 04:13:42 -06:00
|
|
|
}
|
2020-07-01 10:15:20 -05:00
|
|
|
|
2021-11-09 04:13:42 -06:00
|
|
|
// To better support custom derives, collect impls in all unnamed const items.
|
|
|
|
// const _: () = { ... };
|
2021-12-08 08:44:52 -06:00
|
|
|
for konst in collect_unnamed_consts(db, &module_data.scope) {
|
2021-11-09 04:13:42 -06:00
|
|
|
let body = db.body(konst.into());
|
|
|
|
for (_, block_def_map) in body.blocks(db.upcast()) {
|
|
|
|
self.collect_def_map(db, &block_def_map);
|
2020-07-01 10:15:20 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn for_self_ty(&self, self_ty: &Ty) -> &[ImplId] {
|
2021-04-07 12:35:24 -05:00
|
|
|
match TyFingerprint::for_inherent_impl(self_ty) {
|
2020-07-01 10:15:20 -05:00
|
|
|
Some(fp) => self.map.get(&fp).map(|vec| vec.as_ref()).unwrap_or(&[]),
|
|
|
|
None => &[],
|
|
|
|
}
|
2019-08-16 08:34:47 -05:00
|
|
|
}
|
|
|
|
|
2020-07-01 10:15:20 -05:00
|
|
|
pub fn all_impls(&self) -> impl Iterator<Item = ImplId> + '_ {
|
|
|
|
self.map.values().flat_map(|v| v.iter().copied())
|
2019-01-31 17:34:52 -06:00
|
|
|
}
|
2023-01-20 16:09:35 -06:00
|
|
|
|
|
|
|
pub fn invalid_impls(&self) -> &[ImplId] {
|
|
|
|
&self.invalid_impls
|
|
|
|
}
|
2019-01-07 06:44:54 -06:00
|
|
|
}
|
|
|
|
|
2022-12-04 13:12:11 -06:00
|
|
|
pub(crate) fn incoherent_inherent_impl_crates(
|
2022-04-02 08:32:40 -05:00
|
|
|
db: &dyn HirDatabase,
|
|
|
|
krate: CrateId,
|
|
|
|
fp: TyFingerprint,
|
2022-12-04 13:12:11 -06:00
|
|
|
) -> SmallVec<[CrateId; 2]> {
|
2022-04-02 08:32:40 -05:00
|
|
|
let _p = profile::span("inherent_impl_crates_query");
|
2022-12-04 13:12:11 -06:00
|
|
|
let mut res = SmallVec::new();
|
2022-04-02 08:32:40 -05:00
|
|
|
let crate_graph = db.crate_graph();
|
|
|
|
|
2022-12-04 13:12:11 -06:00
|
|
|
// should pass crate for finger print and do reverse deps
|
|
|
|
|
2022-04-02 08:32:40 -05:00
|
|
|
for krate in crate_graph.transitive_deps(krate) {
|
|
|
|
let impls = db.inherent_impls_in_crate(krate);
|
|
|
|
if impls.map.get(&fp).map_or(false, |v| !v.is_empty()) {
|
|
|
|
res.push(krate);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
res
|
|
|
|
}
|
|
|
|
|
2021-12-08 08:44:52 -06:00
|
|
|
fn collect_unnamed_consts<'a>(
|
|
|
|
db: &'a dyn HirDatabase,
|
|
|
|
scope: &'a ItemScope,
|
|
|
|
) -> impl Iterator<Item = ConstId> + 'a {
|
|
|
|
let unnamed_consts = scope.unnamed_consts();
|
|
|
|
|
|
|
|
// FIXME: Also treat consts named `_DERIVE_*` as unnamed, since synstructure generates those.
|
|
|
|
// Should be removed once synstructure stops doing that.
|
|
|
|
let synstructure_hack_consts = scope.values().filter_map(|(item, _)| match item {
|
|
|
|
ModuleDefId::ConstId(id) => {
|
|
|
|
let loc = id.lookup(db.upcast());
|
|
|
|
let item_tree = loc.id.item_tree(db.upcast());
|
|
|
|
if item_tree[loc.id.value]
|
|
|
|
.name
|
|
|
|
.as_ref()
|
|
|
|
.map_or(false, |n| n.to_smol_str().starts_with("_DERIVE_"))
|
|
|
|
{
|
|
|
|
Some(id)
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_ => None,
|
|
|
|
});
|
|
|
|
|
|
|
|
unnamed_consts.chain(synstructure_hack_consts)
|
|
|
|
}
|
|
|
|
|
2021-04-07 06:09:31 -05:00
|
|
|
pub fn def_crates(
|
|
|
|
db: &dyn HirDatabase,
|
|
|
|
ty: &Ty,
|
|
|
|
cur_crate: CrateId,
|
2022-12-04 13:12:11 -06:00
|
|
|
) -> Option<SmallVec<[CrateId; 2]>> {
|
2022-04-02 08:32:40 -05:00
|
|
|
match ty.kind(Interner) {
|
2022-12-04 13:12:11 -06:00
|
|
|
&TyKind::Adt(AdtId(def_id), _) => {
|
|
|
|
let rustc_has_incoherent_inherent_impls = match def_id {
|
|
|
|
hir_def::AdtId::StructId(id) => {
|
|
|
|
db.struct_data(id).rustc_has_incoherent_inherent_impls
|
|
|
|
}
|
|
|
|
hir_def::AdtId::UnionId(id) => {
|
|
|
|
db.union_data(id).rustc_has_incoherent_inherent_impls
|
|
|
|
}
|
|
|
|
hir_def::AdtId::EnumId(id) => db.enum_data(id).rustc_has_incoherent_inherent_impls,
|
|
|
|
};
|
|
|
|
Some(if rustc_has_incoherent_inherent_impls {
|
|
|
|
db.incoherent_inherent_impl_crates(cur_crate, TyFingerprint::Adt(def_id))
|
|
|
|
} else {
|
|
|
|
smallvec![def_id.module(db.upcast()).krate()]
|
|
|
|
})
|
|
|
|
}
|
|
|
|
&TyKind::Foreign(id) => {
|
|
|
|
let alias = from_foreign_def_id(id);
|
|
|
|
Some(if db.type_alias_data(alias).rustc_has_incoherent_inherent_impls {
|
|
|
|
db.incoherent_inherent_impl_crates(cur_crate, TyFingerprint::ForeignType(id))
|
|
|
|
} else {
|
|
|
|
smallvec![alias.module(db.upcast()).krate()]
|
|
|
|
})
|
|
|
|
}
|
|
|
|
TyKind::Dyn(_) => {
|
|
|
|
let trait_id = ty.dyn_trait()?;
|
|
|
|
Some(if db.trait_data(trait_id).rustc_has_incoherent_inherent_impls {
|
|
|
|
db.incoherent_inherent_impl_crates(cur_crate, TyFingerprint::Dyn(trait_id))
|
|
|
|
} else {
|
|
|
|
smallvec![trait_id.module(db.upcast()).krate()]
|
|
|
|
})
|
2021-04-07 06:09:31 -05:00
|
|
|
}
|
2022-04-02 08:32:40 -05:00
|
|
|
// for primitives, there may be impls in various places (core and alloc
|
|
|
|
// mostly). We just check the whole crate graph for crates with impls
|
|
|
|
// (cached behind a query).
|
|
|
|
TyKind::Scalar(_)
|
|
|
|
| TyKind::Str
|
|
|
|
| TyKind::Slice(_)
|
|
|
|
| TyKind::Array(..)
|
2022-12-04 13:12:11 -06:00
|
|
|
| TyKind::Raw(..) => Some(db.incoherent_inherent_impl_crates(
|
|
|
|
cur_crate,
|
|
|
|
TyFingerprint::for_inherent_impl(ty).expect("fingerprint for primitive"),
|
|
|
|
)),
|
|
|
|
_ => None,
|
2022-04-02 08:32:40 -05:00
|
|
|
}
|
2022-08-08 23:23:57 -05:00
|
|
|
}
|
|
|
|
|
2023-01-21 10:29:07 -06:00
|
|
|
pub fn lang_items_for_bin_op(op: syntax::ast::BinaryOp) -> Option<(Name, LangItem)> {
|
2022-08-08 23:23:57 -05:00
|
|
|
use hir_expand::name;
|
|
|
|
use syntax::ast::{ArithOp, BinaryOp, CmpOp, Ordering};
|
|
|
|
Some(match op {
|
|
|
|
BinaryOp::LogicOp(_) => return None,
|
|
|
|
BinaryOp::ArithOp(aop) => match aop {
|
2023-01-21 10:29:07 -06:00
|
|
|
ArithOp::Add => (name![add], LangItem::Add),
|
|
|
|
ArithOp::Mul => (name![mul], LangItem::Mul),
|
|
|
|
ArithOp::Sub => (name![sub], LangItem::Sub),
|
|
|
|
ArithOp::Div => (name![div], LangItem::Div),
|
|
|
|
ArithOp::Rem => (name![rem], LangItem::Rem),
|
|
|
|
ArithOp::Shl => (name![shl], LangItem::Shl),
|
|
|
|
ArithOp::Shr => (name![shr], LangItem::Shr),
|
|
|
|
ArithOp::BitXor => (name![bitxor], LangItem::BitXor),
|
|
|
|
ArithOp::BitOr => (name![bitor], LangItem::BitOr),
|
|
|
|
ArithOp::BitAnd => (name![bitand], LangItem::BitAnd),
|
2022-08-08 23:23:57 -05:00
|
|
|
},
|
|
|
|
BinaryOp::Assignment { op: Some(aop) } => match aop {
|
2023-01-21 10:29:07 -06:00
|
|
|
ArithOp::Add => (name![add_assign], LangItem::AddAssign),
|
|
|
|
ArithOp::Mul => (name![mul_assign], LangItem::MulAssign),
|
|
|
|
ArithOp::Sub => (name![sub_assign], LangItem::SubAssign),
|
|
|
|
ArithOp::Div => (name![div_assign], LangItem::DivAssign),
|
|
|
|
ArithOp::Rem => (name![rem_assign], LangItem::RemAssign),
|
|
|
|
ArithOp::Shl => (name![shl_assign], LangItem::ShlAssign),
|
|
|
|
ArithOp::Shr => (name![shr_assign], LangItem::ShrAssign),
|
|
|
|
ArithOp::BitXor => (name![bitxor_assign], LangItem::BitXorAssign),
|
|
|
|
ArithOp::BitOr => (name![bitor_assign], LangItem::BitOrAssign),
|
|
|
|
ArithOp::BitAnd => (name![bitand_assign], LangItem::BitAndAssign),
|
2022-08-08 23:23:57 -05:00
|
|
|
},
|
|
|
|
BinaryOp::CmpOp(cop) => match cop {
|
2023-01-21 10:29:07 -06:00
|
|
|
CmpOp::Eq { negated: false } => (name![eq], LangItem::PartialEq),
|
|
|
|
CmpOp::Eq { negated: true } => (name![ne], LangItem::PartialEq),
|
2022-08-08 23:23:57 -05:00
|
|
|
CmpOp::Ord { ordering: Ordering::Less, strict: false } => {
|
2023-01-21 10:29:07 -06:00
|
|
|
(name![le], LangItem::PartialOrd)
|
2022-08-08 23:23:57 -05:00
|
|
|
}
|
|
|
|
CmpOp::Ord { ordering: Ordering::Less, strict: true } => {
|
2023-01-21 10:29:07 -06:00
|
|
|
(name![lt], LangItem::PartialOrd)
|
2022-08-08 23:23:57 -05:00
|
|
|
}
|
|
|
|
CmpOp::Ord { ordering: Ordering::Greater, strict: false } => {
|
2023-01-21 10:29:07 -06:00
|
|
|
(name![ge], LangItem::PartialOrd)
|
2022-08-08 23:23:57 -05:00
|
|
|
}
|
|
|
|
CmpOp::Ord { ordering: Ordering::Greater, strict: true } => {
|
2023-01-21 10:29:07 -06:00
|
|
|
(name![gt], LangItem::PartialOrd)
|
2022-08-08 23:23:57 -05:00
|
|
|
}
|
|
|
|
},
|
|
|
|
BinaryOp::Assignment { op: None } => return None,
|
|
|
|
})
|
2019-01-07 06:44:54 -06:00
|
|
|
}
|
2021-02-08 12:13:54 -06:00
|
|
|
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
/// Look up the method with the given name.
|
2019-05-01 10:57:56 -05:00
|
|
|
pub(crate) fn lookup_method(
|
2020-03-13 10:05:46 -05:00
|
|
|
db: &dyn HirDatabase,
|
2023-01-01 06:24:48 -06:00
|
|
|
ty: &Canonical<Ty>,
|
2020-01-14 07:20:33 -06:00
|
|
|
env: Arc<TraitEnvironment>,
|
|
|
|
traits_in_scope: &FxHashSet<TraitId>,
|
2022-02-01 16:29:40 -06:00
|
|
|
visible_from_module: VisibleFromModule,
|
2019-05-01 10:57:56 -05:00
|
|
|
name: &Name,
|
2023-01-01 06:24:48 -06:00
|
|
|
) -> Option<(ReceiverAdjustments, FunctionId, bool)> {
|
2022-12-30 16:56:08 -06:00
|
|
|
let mut not_visible = None;
|
|
|
|
let res = iterate_method_candidates(
|
2020-01-14 07:20:33 -06:00
|
|
|
ty,
|
|
|
|
db,
|
|
|
|
env,
|
2021-06-12 22:54:16 -05:00
|
|
|
traits_in_scope,
|
2021-03-20 13:28:26 -05:00
|
|
|
visible_from_module,
|
2020-01-14 07:20:33 -06:00
|
|
|
Some(name),
|
|
|
|
LookupMode::MethodCall,
|
2022-12-30 16:56:08 -06:00
|
|
|
|adjustments, f, visible| match f {
|
2023-01-01 06:24:48 -06:00
|
|
|
AssocItemId::FunctionId(f) if visible => Some((adjustments, f, true)),
|
2022-12-30 16:56:08 -06:00
|
|
|
AssocItemId::FunctionId(f) if not_visible.is_none() => {
|
2023-01-01 06:24:48 -06:00
|
|
|
not_visible = Some((adjustments, f, false));
|
2022-12-30 16:56:08 -06:00
|
|
|
None
|
|
|
|
}
|
2020-01-14 07:20:33 -06:00
|
|
|
_ => None,
|
|
|
|
},
|
2022-12-30 16:56:08 -06:00
|
|
|
);
|
|
|
|
res.or(not_visible)
|
2019-10-31 13:28:33 -05:00
|
|
|
}
|
|
|
|
|
2019-11-01 05:53:29 -05:00
|
|
|
/// Whether we're looking up a dotted method call (like `v.len()`) or a path
|
|
|
|
/// (like `Vec::new`).
|
2019-10-31 13:28:33 -05:00
|
|
|
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
|
2019-10-31 15:21:48 -05:00
|
|
|
pub enum LookupMode {
|
2019-11-01 05:53:29 -05:00
|
|
|
/// Looking up a method call like `v.len()`: We only consider candidates
|
|
|
|
/// that have a `self` parameter, and do autoderef.
|
2019-10-31 13:28:33 -05:00
|
|
|
MethodCall,
|
2019-11-01 05:53:29 -05:00
|
|
|
/// Looking up a path like `Vec::new` or `Vec::default`: We consider all
|
|
|
|
/// candidates including associated constants, but don't do autoderef.
|
2019-10-31 13:28:33 -05:00
|
|
|
Path,
|
2019-05-01 10:57:56 -05:00
|
|
|
}
|
2019-03-24 11:36:15 -05:00
|
|
|
|
2022-02-01 16:29:40 -06:00
|
|
|
#[derive(Clone, Copy)]
|
|
|
|
pub enum VisibleFromModule {
|
|
|
|
/// Filter for results that are visible from the given module
|
|
|
|
Filter(ModuleId),
|
|
|
|
/// Include impls from the given block.
|
|
|
|
IncludeBlock(BlockId),
|
|
|
|
/// Do nothing special in regards visibility
|
|
|
|
None,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl From<Option<ModuleId>> for VisibleFromModule {
|
|
|
|
fn from(module: Option<ModuleId>) -> Self {
|
|
|
|
match module {
|
|
|
|
Some(module) => Self::Filter(module),
|
|
|
|
None => Self::None,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl From<Option<BlockId>> for VisibleFromModule {
|
|
|
|
fn from(block: Option<BlockId>) -> Self {
|
|
|
|
match block {
|
|
|
|
Some(block) => Self::IncludeBlock(block),
|
|
|
|
None => Self::None,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
#[derive(Debug, Clone, Default)]
|
|
|
|
pub struct ReceiverAdjustments {
|
|
|
|
autoref: Option<Mutability>,
|
|
|
|
autoderefs: usize,
|
|
|
|
unsize_array: bool,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ReceiverAdjustments {
|
2022-07-20 08:02:08 -05:00
|
|
|
pub(crate) fn apply(&self, table: &mut InferenceTable<'_>, ty: Ty) -> (Ty, Vec<Adjustment>) {
|
2022-11-23 09:24:03 -06:00
|
|
|
let mut ty = table.resolve_ty_shallow(&ty);
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
let mut adjust = Vec::new();
|
|
|
|
for _ in 0..self.autoderefs {
|
|
|
|
match autoderef::autoderef_step(table, ty.clone()) {
|
|
|
|
None => {
|
|
|
|
never!("autoderef not possible for {:?}", ty);
|
|
|
|
ty = TyKind::Error.intern(Interner);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
Some((kind, new_ty)) => {
|
|
|
|
ty = new_ty.clone();
|
|
|
|
adjust.push(Adjustment {
|
|
|
|
kind: Adjust::Deref(match kind {
|
2023-03-04 14:08:04 -06:00
|
|
|
// FIXME should we know the mutability here, when autoref is `None`?
|
|
|
|
AutoderefKind::Overloaded => Some(OverloadedDeref(self.autoref)),
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
AutoderefKind::Builtin => None,
|
|
|
|
}),
|
|
|
|
target: new_ty,
|
|
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2023-01-31 10:53:38 -06:00
|
|
|
if let Some(m) = self.autoref {
|
|
|
|
ty = TyKind::Ref(m, static_lifetime(), ty).intern(Interner);
|
|
|
|
adjust
|
|
|
|
.push(Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(m)), target: ty.clone() });
|
|
|
|
}
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
if self.unsize_array {
|
2023-01-31 10:53:38 -06:00
|
|
|
ty = 'x: {
|
|
|
|
if let TyKind::Ref(m, l, inner) = ty.kind(Interner) {
|
|
|
|
if let TyKind::Array(inner, _) = inner.kind(Interner) {
|
|
|
|
break 'x TyKind::Ref(
|
|
|
|
m.clone(),
|
|
|
|
l.clone(),
|
|
|
|
TyKind::Slice(inner.clone()).intern(Interner),
|
|
|
|
)
|
|
|
|
.intern(Interner);
|
|
|
|
}
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
}
|
2023-01-31 10:53:38 -06:00
|
|
|
never!("unsize_array with non-reference-to-array {:?}", ty);
|
|
|
|
ty
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
};
|
|
|
|
adjust.push(Adjustment {
|
|
|
|
kind: Adjust::Pointer(PointerCast::Unsize),
|
|
|
|
target: ty.clone(),
|
|
|
|
});
|
|
|
|
}
|
|
|
|
(ty, adjust)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn with_autoref(&self, m: Mutability) -> ReceiverAdjustments {
|
|
|
|
Self { autoref: Some(m), ..*self }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-01 10:57:56 -05:00
|
|
|
// This would be nicer if it just returned an iterator, but that runs into
|
2020-02-29 14:24:40 -06:00
|
|
|
// lifetime problems, because we need to borrow temp `CrateImplDefs`.
|
2019-11-01 13:56:56 -05:00
|
|
|
// FIXME add a context type here?
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
pub(crate) fn iterate_method_candidates<T>(
|
2019-05-01 10:57:56 -05:00
|
|
|
ty: &Canonical<Ty>,
|
2020-03-13 10:05:46 -05:00
|
|
|
db: &dyn HirDatabase,
|
2020-01-14 07:20:33 -06:00
|
|
|
env: Arc<TraitEnvironment>,
|
|
|
|
traits_in_scope: &FxHashSet<TraitId>,
|
2022-02-01 16:29:40 -06:00
|
|
|
visible_from_module: VisibleFromModule,
|
2019-05-01 10:57:56 -05:00
|
|
|
name: Option<&Name>,
|
2019-10-31 13:28:33 -05:00
|
|
|
mode: LookupMode,
|
2022-12-30 16:56:08 -06:00
|
|
|
mut callback: impl FnMut(ReceiverAdjustments, AssocItemId, bool) -> Option<T>,
|
2019-05-01 10:57:56 -05:00
|
|
|
) -> Option<T> {
|
2020-06-24 10:45:38 -05:00
|
|
|
let mut slot = None;
|
internal: improve compile times a bit
before after for cargo llvm-lines -q --lib --release -p ide_ssr | head -n 24
Lines Copies Function name
----- ------ -------------
297146 (100%) 12748 (100%) (TOTAL)
5970 (2.0%) 47 (0.4%) core::iter::traits::iterator::Iterator::try_fold
4750 (1.6%) 27 (0.2%) hashbrown::raw::RawTable<T,A>::resize
4080 (1.4%) 30 (0.2%) alloc::raw_vec::RawVec<T,A>::grow_amortized
3933 (1.3%) 69 (0.5%) alloc::raw_vec::RawVec<T,A>::current_memory
3668 (1.2%) 89 (0.7%) <core::result::Result<T,E> as core::ops::try_trait::Try>::branch
3500 (1.2%) 50 (0.4%) hashbrown::raw::RawTable<T,A>::drop_elements
3436 (1.2%) 33 (0.3%) hashbrown::raw::RawTable<T,A>::find
3415 (1.1%) 17 (0.1%) hashbrown::raw::RawTable<T,A>::rehash_in_place
3400 (1.1%) 50 (0.4%) <hashbrown::raw::RawIterRange<T> as core::iter::traits::iterator::Iterator>::next
2840 (1.0%) 20 (0.2%) alloc::raw_vec::RawVec<T,A>::allocate_in
2700 (0.9%) 30 (0.2%) core::alloc::layout::Layout::array
2666 (0.9%) 86 (0.7%) core::ptr::metadata::from_raw_parts_mut
2495 (0.8%) 50 (0.4%) core::option::Option<T>::map
2354 (0.8%) 38 (0.3%) alloc::alloc::box_free
2302 (0.8%) 7 (0.1%) ide_ssr::parsing::RuleBuilder::try_add
2146 (0.7%) 45 (0.4%) core::mem::replace
2070 (0.7%) 69 (0.5%) <alloc::raw_vec::RawVec<T,A> as core::ops::drop::Drop>::drop
1979 (0.7%) 16 (0.1%) hashbrown::map::HashMap<K,V,S,A>::insert
1926 (0.6%) 18 (0.1%) <core::iter::adapters::zip::Zip<A,B> as core::iter::adapters::zip::ZipImpl<A,B>>::next
1922 (0.6%) 62 (0.5%) core::fmt::ArgumentV1::new
1885 (0.6%) 13 (0.1%) alloc::raw_vec::RawVec<T,A>::shrink
Lines Copies Function name
----- ------ -------------
261717 (100%) 11666 (100%) (TOTAL)
5239 (2.0%) 42 (0.4%) core::iter::traits::iterator::Iterator::try_fold
4750 (1.8%) 27 (0.2%) hashbrown::raw::RawTable<T,A>::resize
3933 (1.5%) 69 (0.6%) alloc::raw_vec::RawVec<T,A>::current_memory
3536 (1.4%) 26 (0.2%) alloc::raw_vec::RawVec<T,A>::grow_amortized
3500 (1.3%) 50 (0.4%) hashbrown::raw::RawTable<T,A>::drop_elements
3400 (1.3%) 50 (0.4%) <hashbrown::raw::RawIterRange<T> as core::iter::traits::iterator::Iterator>::next
3124 (1.2%) 30 (0.3%) hashbrown::raw::RawTable<T,A>::find
2812 (1.1%) 14 (0.1%) hashbrown::raw::RawTable<T,A>::rehash_in_place
2604 (1.0%) 84 (0.7%) core::ptr::metadata::from_raw_parts_mut
2340 (0.9%) 26 (0.2%) core::alloc::layout::Layout::array
2302 (0.9%) 7 (0.1%) ide_ssr::parsing::RuleBuilder::try_add
2272 (0.9%) 16 (0.1%) alloc::raw_vec::RawVec<T,A>::allocate_in
2201 (0.8%) 35 (0.3%) alloc::alloc::box_free
2104 (0.8%) 44 (0.4%) core::mem::replace
2079 (0.8%) 42 (0.4%) <core::result::Result<T,E> as core::ops::try_trait::Try>::branch
2070 (0.8%) 69 (0.6%) <alloc::raw_vec::RawVec<T,A> as core::ops::drop::Drop>::drop
1926 (0.7%) 18 (0.2%) <core::iter::adapters::zip::Zip<A,B> as core::iter::adapters::zip::ZipImpl<A,B>>::next
1885 (0.7%) 13 (0.1%) alloc::raw_vec::RawVec<T,A>::shrink
1833 (0.7%) 13 (0.1%) hashbrown::raw::RawTable<T,A>::shrink_to
1771 (0.7%) 91 (0.8%) core::ptr::read
1701 (0.6%) 35 (0.3%) core::option::Option<T>::map
2021-08-29 10:49:16 -05:00
|
|
|
iterate_method_candidates_dyn(
|
2020-06-24 10:45:38 -05:00
|
|
|
ty,
|
|
|
|
db,
|
|
|
|
env,
|
|
|
|
traits_in_scope,
|
2021-03-20 13:28:26 -05:00
|
|
|
visible_from_module,
|
2020-06-24 10:45:38 -05:00
|
|
|
name,
|
|
|
|
mode,
|
2022-12-30 16:56:08 -06:00
|
|
|
&mut |adj, item, visible| {
|
2020-06-26 05:04:11 -05:00
|
|
|
assert!(slot.is_none());
|
2022-12-30 16:56:08 -06:00
|
|
|
if let Some(it) = callback(adj, item, visible) {
|
2021-09-11 12:49:10 -05:00
|
|
|
slot = Some(it);
|
|
|
|
return ControlFlow::Break(());
|
|
|
|
}
|
|
|
|
ControlFlow::Continue(())
|
2020-06-24 10:45:38 -05:00
|
|
|
},
|
|
|
|
);
|
|
|
|
slot
|
|
|
|
}
|
|
|
|
|
2022-12-04 19:53:11 -06:00
|
|
|
pub fn lookup_impl_const(
|
|
|
|
db: &dyn HirDatabase,
|
|
|
|
env: Arc<TraitEnvironment>,
|
|
|
|
const_id: ConstId,
|
|
|
|
subs: Substitution,
|
2023-02-03 05:16:25 -06:00
|
|
|
) -> (ConstId, Substitution) {
|
2022-12-04 19:53:11 -06:00
|
|
|
let trait_id = match const_id.lookup(db.upcast()).container {
|
|
|
|
ItemContainerId::TraitId(id) => id,
|
2023-02-03 05:16:25 -06:00
|
|
|
_ => return (const_id, subs),
|
2022-12-04 19:53:11 -06:00
|
|
|
};
|
|
|
|
let substitution = Substitution::from_iter(Interner, subs.iter(Interner));
|
|
|
|
let trait_ref = TraitRef { trait_id: to_chalk_trait_id(trait_id), substitution };
|
|
|
|
|
|
|
|
let const_data = db.const_data(const_id);
|
|
|
|
let name = match const_data.name.as_ref() {
|
|
|
|
Some(name) => name,
|
2023-02-03 05:16:25 -06:00
|
|
|
None => return (const_id, subs),
|
2022-12-04 19:53:11 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
lookup_impl_assoc_item_for_trait_ref(trait_ref, db, env, name)
|
2023-02-03 05:16:25 -06:00
|
|
|
.and_then(
|
|
|
|
|assoc| if let (AssocItemId::ConstId(id), s) = assoc { Some((id, s)) } else { None },
|
|
|
|
)
|
|
|
|
.unwrap_or((const_id, subs))
|
2022-12-04 19:53:11 -06:00
|
|
|
}
|
|
|
|
|
2022-11-01 04:31:31 -05:00
|
|
|
/// Looks up the impl method that actually runs for the trait method `func`.
|
|
|
|
///
|
|
|
|
/// Returns `func` if it's not a method defined in a trait or the lookup failed.
|
2022-06-23 07:10:12 -05:00
|
|
|
pub fn lookup_impl_method(
|
2022-06-15 10:13:15 -05:00
|
|
|
db: &dyn HirDatabase,
|
|
|
|
env: Arc<TraitEnvironment>,
|
2022-11-01 04:31:31 -05:00
|
|
|
func: FunctionId,
|
|
|
|
fn_subst: Substitution,
|
2023-02-03 05:16:25 -06:00
|
|
|
) -> (FunctionId, Substitution) {
|
2022-11-01 04:31:31 -05:00
|
|
|
let trait_id = match func.lookup(db.upcast()).container {
|
|
|
|
ItemContainerId::TraitId(id) => id,
|
2023-02-03 05:16:25 -06:00
|
|
|
_ => return (func, fn_subst),
|
2022-11-01 04:31:31 -05:00
|
|
|
};
|
|
|
|
let trait_params = db.generic_params(trait_id.into()).type_or_consts.len();
|
|
|
|
let fn_params = fn_subst.len(Interner) - trait_params;
|
|
|
|
let trait_ref = TraitRef {
|
|
|
|
trait_id: to_chalk_trait_id(trait_id),
|
|
|
|
substitution: Substitution::from_iter(Interner, fn_subst.iter(Interner).skip(fn_params)),
|
|
|
|
};
|
|
|
|
|
|
|
|
let name = &db.function_data(func).name;
|
2022-12-04 19:53:11 -06:00
|
|
|
lookup_impl_assoc_item_for_trait_ref(trait_ref, db, env, name)
|
2023-02-03 05:16:25 -06:00
|
|
|
.and_then(|assoc| {
|
|
|
|
if let (AssocItemId::FunctionId(id), subst) = assoc {
|
|
|
|
Some((id, subst))
|
|
|
|
} else {
|
|
|
|
None
|
|
|
|
}
|
|
|
|
})
|
|
|
|
.unwrap_or((func, fn_subst))
|
2022-11-01 04:31:31 -05:00
|
|
|
}
|
|
|
|
|
2022-12-04 19:53:11 -06:00
|
|
|
fn lookup_impl_assoc_item_for_trait_ref(
|
2022-11-01 04:31:31 -05:00
|
|
|
trait_ref: TraitRef,
|
|
|
|
db: &dyn HirDatabase,
|
|
|
|
env: Arc<TraitEnvironment>,
|
2022-06-15 10:13:15 -05:00
|
|
|
name: &Name,
|
2023-02-03 05:16:25 -06:00
|
|
|
) -> Option<(AssocItemId, Substitution)> {
|
2022-11-01 04:31:31 -05:00
|
|
|
let self_ty = trait_ref.self_type_parameter(Interner);
|
|
|
|
let self_ty_fp = TyFingerprint::for_trait_impl(&self_ty)?;
|
|
|
|
let impls = db.trait_impls_in_deps(env.krate);
|
|
|
|
let impls = impls.for_trait_and_self_ty(trait_ref.hir_trait_id(), self_ty_fp);
|
|
|
|
|
|
|
|
let table = InferenceTable::new(db, env);
|
|
|
|
|
2023-02-03 05:16:25 -06:00
|
|
|
let (impl_data, impl_subst) = find_matching_impl(impls, table, trait_ref)?;
|
|
|
|
let item = impl_data.items.iter().find_map(|&it| match it {
|
2022-12-04 19:53:11 -06:00
|
|
|
AssocItemId::FunctionId(f) => {
|
2023-01-11 10:10:04 -06:00
|
|
|
(db.function_data(f).name == *name).then_some(AssocItemId::FunctionId(f))
|
2022-12-04 19:53:11 -06:00
|
|
|
}
|
|
|
|
AssocItemId::ConstId(c) => db
|
2023-01-11 10:10:04 -06:00
|
|
|
.const_data(c)
|
2022-12-04 19:53:11 -06:00
|
|
|
.name
|
|
|
|
.as_ref()
|
2023-01-11 10:10:04 -06:00
|
|
|
.map(|n| n == name)
|
|
|
|
.and_then(|result| if result { Some(AssocItemId::ConstId(c)) } else { None }),
|
|
|
|
AssocItemId::TypeAliasId(_) => None,
|
2023-02-03 05:16:25 -06:00
|
|
|
})?;
|
|
|
|
Some((item, impl_subst))
|
2022-06-23 07:10:12 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
fn find_matching_impl(
|
|
|
|
mut impls: impl Iterator<Item = ImplId>,
|
2022-11-01 04:31:31 -05:00
|
|
|
mut table: InferenceTable<'_>,
|
|
|
|
actual_trait_ref: TraitRef,
|
2023-02-03 05:16:25 -06:00
|
|
|
) -> Option<(Arc<ImplData>, Substitution)> {
|
2022-06-23 07:10:12 -05:00
|
|
|
let db = table.db;
|
|
|
|
loop {
|
|
|
|
let impl_ = impls.next()?;
|
|
|
|
let r = table.run_in_snapshot(|table| {
|
|
|
|
let impl_data = db.impl_data(impl_);
|
2022-11-01 04:31:31 -05:00
|
|
|
let impl_substs =
|
2022-10-11 02:37:35 -05:00
|
|
|
TyBuilder::subst_for_def(db, impl_, None).fill_with_inference_vars(table).build();
|
2022-11-01 04:31:31 -05:00
|
|
|
let trait_ref = db
|
|
|
|
.impl_trait(impl_)
|
|
|
|
.expect("non-trait method in find_matching_impl")
|
|
|
|
.substitute(Interner, &impl_substs);
|
2022-06-23 07:10:12 -05:00
|
|
|
|
2022-11-01 04:31:31 -05:00
|
|
|
if !table.unify(&trait_ref, &actual_trait_ref) {
|
|
|
|
return None;
|
|
|
|
}
|
2022-06-23 07:10:12 -05:00
|
|
|
|
2022-11-01 04:31:31 -05:00
|
|
|
let wcs = crate::chalk_db::convert_where_clauses(db, impl_.into(), &impl_substs)
|
|
|
|
.into_iter()
|
|
|
|
.map(|b| b.cast(Interner));
|
|
|
|
let goal = crate::Goal::all(Interner, wcs);
|
2023-02-03 05:16:25 -06:00
|
|
|
table.try_obligation(goal).map(|_| (impl_data, table.resolve_completely(impl_substs)))
|
2022-06-23 07:10:12 -05:00
|
|
|
});
|
|
|
|
if r.is_some() {
|
|
|
|
break r;
|
2022-06-15 10:13:15 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-20 16:09:35 -06:00
|
|
|
fn is_inherent_impl_coherent(
|
|
|
|
db: &dyn HirDatabase,
|
|
|
|
def_map: &DefMap,
|
|
|
|
impl_data: &ImplData,
|
|
|
|
self_ty: &Ty,
|
|
|
|
) -> bool {
|
|
|
|
let self_ty = self_ty.kind(Interner);
|
|
|
|
let impl_allowed = match self_ty {
|
|
|
|
TyKind::Tuple(_, _)
|
|
|
|
| TyKind::FnDef(_, _)
|
|
|
|
| TyKind::Array(_, _)
|
|
|
|
| TyKind::Never
|
|
|
|
| TyKind::Raw(_, _)
|
|
|
|
| TyKind::Ref(_, _, _)
|
|
|
|
| TyKind::Slice(_)
|
|
|
|
| TyKind::Str
|
|
|
|
| TyKind::Scalar(_) => def_map.is_rustc_coherence_is_core(),
|
|
|
|
|
|
|
|
&TyKind::Adt(AdtId(adt), _) => adt.module(db.upcast()).krate() == def_map.krate(),
|
|
|
|
// FIXME: Factor out the principal trait fetching into a function
|
|
|
|
TyKind::Dyn(it) => it
|
|
|
|
.bounds
|
|
|
|
.skip_binders()
|
|
|
|
.interned()
|
|
|
|
.get(0)
|
|
|
|
.and_then(|b| match b.skip_binders() {
|
|
|
|
crate::WhereClause::Implemented(trait_ref) => Some(trait_ref),
|
|
|
|
_ => None,
|
|
|
|
})
|
|
|
|
.map_or(false, |trait_ref| {
|
|
|
|
from_chalk_trait_id(trait_ref.trait_id).module(db.upcast()).krate()
|
|
|
|
== def_map.krate()
|
|
|
|
}),
|
|
|
|
|
|
|
|
_ => true,
|
|
|
|
};
|
|
|
|
impl_allowed || {
|
|
|
|
let rustc_has_incoherent_inherent_impls = match self_ty {
|
|
|
|
TyKind::Tuple(_, _)
|
|
|
|
| TyKind::FnDef(_, _)
|
|
|
|
| TyKind::Array(_, _)
|
|
|
|
| TyKind::Never
|
|
|
|
| TyKind::Raw(_, _)
|
|
|
|
| TyKind::Ref(_, _, _)
|
|
|
|
| TyKind::Slice(_)
|
|
|
|
| TyKind::Str
|
|
|
|
| TyKind::Scalar(_) => true,
|
|
|
|
|
|
|
|
&TyKind::Adt(AdtId(adt), _) => match adt {
|
|
|
|
hir_def::AdtId::StructId(it) => {
|
|
|
|
db.struct_data(it).rustc_has_incoherent_inherent_impls
|
|
|
|
}
|
|
|
|
hir_def::AdtId::UnionId(it) => {
|
|
|
|
db.union_data(it).rustc_has_incoherent_inherent_impls
|
|
|
|
}
|
|
|
|
hir_def::AdtId::EnumId(it) => db.enum_data(it).rustc_has_incoherent_inherent_impls,
|
|
|
|
},
|
|
|
|
// FIXME: Factor out the principal trait fetching into a function
|
|
|
|
TyKind::Dyn(it) => it
|
|
|
|
.bounds
|
|
|
|
.skip_binders()
|
|
|
|
.interned()
|
|
|
|
.get(0)
|
|
|
|
.and_then(|b| match b.skip_binders() {
|
|
|
|
crate::WhereClause::Implemented(trait_ref) => Some(trait_ref),
|
|
|
|
_ => None,
|
|
|
|
})
|
|
|
|
.map_or(false, |trait_ref| {
|
|
|
|
db.trait_data(from_chalk_trait_id(trait_ref.trait_id))
|
|
|
|
.rustc_has_incoherent_inherent_impls
|
|
|
|
}),
|
|
|
|
|
|
|
|
_ => false,
|
|
|
|
};
|
|
|
|
rustc_has_incoherent_inherent_impls
|
|
|
|
&& !impl_data.items.is_empty()
|
|
|
|
&& impl_data.items.iter().copied().all(|assoc| match assoc {
|
|
|
|
AssocItemId::FunctionId(it) => db.function_data(it).rustc_allow_incoherent_impl,
|
|
|
|
AssocItemId::ConstId(it) => db.const_data(it).rustc_allow_incoherent_impl,
|
|
|
|
AssocItemId::TypeAliasId(it) => db.type_alias_data(it).rustc_allow_incoherent_impl,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
pub fn iterate_path_candidates(
|
|
|
|
ty: &Canonical<Ty>,
|
|
|
|
db: &dyn HirDatabase,
|
|
|
|
env: Arc<TraitEnvironment>,
|
|
|
|
traits_in_scope: &FxHashSet<TraitId>,
|
|
|
|
visible_from_module: VisibleFromModule,
|
|
|
|
name: Option<&Name>,
|
|
|
|
callback: &mut dyn FnMut(AssocItemId) -> ControlFlow<()>,
|
|
|
|
) -> ControlFlow<()> {
|
|
|
|
iterate_method_candidates_dyn(
|
|
|
|
ty,
|
|
|
|
db,
|
|
|
|
env,
|
|
|
|
traits_in_scope,
|
|
|
|
visible_from_module,
|
|
|
|
name,
|
|
|
|
LookupMode::Path,
|
|
|
|
// the adjustments are not relevant for path lookup
|
2022-12-30 16:56:08 -06:00
|
|
|
&mut |_, id, _| callback(id),
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
)
|
|
|
|
}
|
|
|
|
|
internal: improve compile times a bit
before after for cargo llvm-lines -q --lib --release -p ide_ssr | head -n 24
Lines Copies Function name
----- ------ -------------
297146 (100%) 12748 (100%) (TOTAL)
5970 (2.0%) 47 (0.4%) core::iter::traits::iterator::Iterator::try_fold
4750 (1.6%) 27 (0.2%) hashbrown::raw::RawTable<T,A>::resize
4080 (1.4%) 30 (0.2%) alloc::raw_vec::RawVec<T,A>::grow_amortized
3933 (1.3%) 69 (0.5%) alloc::raw_vec::RawVec<T,A>::current_memory
3668 (1.2%) 89 (0.7%) <core::result::Result<T,E> as core::ops::try_trait::Try>::branch
3500 (1.2%) 50 (0.4%) hashbrown::raw::RawTable<T,A>::drop_elements
3436 (1.2%) 33 (0.3%) hashbrown::raw::RawTable<T,A>::find
3415 (1.1%) 17 (0.1%) hashbrown::raw::RawTable<T,A>::rehash_in_place
3400 (1.1%) 50 (0.4%) <hashbrown::raw::RawIterRange<T> as core::iter::traits::iterator::Iterator>::next
2840 (1.0%) 20 (0.2%) alloc::raw_vec::RawVec<T,A>::allocate_in
2700 (0.9%) 30 (0.2%) core::alloc::layout::Layout::array
2666 (0.9%) 86 (0.7%) core::ptr::metadata::from_raw_parts_mut
2495 (0.8%) 50 (0.4%) core::option::Option<T>::map
2354 (0.8%) 38 (0.3%) alloc::alloc::box_free
2302 (0.8%) 7 (0.1%) ide_ssr::parsing::RuleBuilder::try_add
2146 (0.7%) 45 (0.4%) core::mem::replace
2070 (0.7%) 69 (0.5%) <alloc::raw_vec::RawVec<T,A> as core::ops::drop::Drop>::drop
1979 (0.7%) 16 (0.1%) hashbrown::map::HashMap<K,V,S,A>::insert
1926 (0.6%) 18 (0.1%) <core::iter::adapters::zip::Zip<A,B> as core::iter::adapters::zip::ZipImpl<A,B>>::next
1922 (0.6%) 62 (0.5%) core::fmt::ArgumentV1::new
1885 (0.6%) 13 (0.1%) alloc::raw_vec::RawVec<T,A>::shrink
Lines Copies Function name
----- ------ -------------
261717 (100%) 11666 (100%) (TOTAL)
5239 (2.0%) 42 (0.4%) core::iter::traits::iterator::Iterator::try_fold
4750 (1.8%) 27 (0.2%) hashbrown::raw::RawTable<T,A>::resize
3933 (1.5%) 69 (0.6%) alloc::raw_vec::RawVec<T,A>::current_memory
3536 (1.4%) 26 (0.2%) alloc::raw_vec::RawVec<T,A>::grow_amortized
3500 (1.3%) 50 (0.4%) hashbrown::raw::RawTable<T,A>::drop_elements
3400 (1.3%) 50 (0.4%) <hashbrown::raw::RawIterRange<T> as core::iter::traits::iterator::Iterator>::next
3124 (1.2%) 30 (0.3%) hashbrown::raw::RawTable<T,A>::find
2812 (1.1%) 14 (0.1%) hashbrown::raw::RawTable<T,A>::rehash_in_place
2604 (1.0%) 84 (0.7%) core::ptr::metadata::from_raw_parts_mut
2340 (0.9%) 26 (0.2%) core::alloc::layout::Layout::array
2302 (0.9%) 7 (0.1%) ide_ssr::parsing::RuleBuilder::try_add
2272 (0.9%) 16 (0.1%) alloc::raw_vec::RawVec<T,A>::allocate_in
2201 (0.8%) 35 (0.3%) alloc::alloc::box_free
2104 (0.8%) 44 (0.4%) core::mem::replace
2079 (0.8%) 42 (0.4%) <core::result::Result<T,E> as core::ops::try_trait::Try>::branch
2070 (0.8%) 69 (0.6%) <alloc::raw_vec::RawVec<T,A> as core::ops::drop::Drop>::drop
1926 (0.7%) 18 (0.2%) <core::iter::adapters::zip::Zip<A,B> as core::iter::adapters::zip::ZipImpl<A,B>>::next
1885 (0.7%) 13 (0.1%) alloc::raw_vec::RawVec<T,A>::shrink
1833 (0.7%) 13 (0.1%) hashbrown::raw::RawTable<T,A>::shrink_to
1771 (0.7%) 91 (0.8%) core::ptr::read
1701 (0.6%) 35 (0.3%) core::option::Option<T>::map
2021-08-29 10:49:16 -05:00
|
|
|
pub fn iterate_method_candidates_dyn(
|
2020-06-24 10:45:38 -05:00
|
|
|
ty: &Canonical<Ty>,
|
|
|
|
db: &dyn HirDatabase,
|
|
|
|
env: Arc<TraitEnvironment>,
|
|
|
|
traits_in_scope: &FxHashSet<TraitId>,
|
2022-02-01 16:29:40 -06:00
|
|
|
visible_from_module: VisibleFromModule,
|
2020-06-24 10:45:38 -05:00
|
|
|
name: Option<&Name>,
|
|
|
|
mode: LookupMode,
|
2022-12-30 16:56:08 -06:00
|
|
|
callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
|
2021-09-11 12:49:10 -05:00
|
|
|
) -> ControlFlow<()> {
|
2019-10-31 14:01:46 -05:00
|
|
|
match mode {
|
|
|
|
LookupMode::MethodCall => {
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
// For method calls, rust first does any number of autoderef, and
|
|
|
|
// then one autoref (i.e. when the method takes &self or &mut self).
|
|
|
|
// Note that when we've got a receiver like &S, even if the method
|
|
|
|
// we find in the end takes &self, we still do the autoderef step
|
|
|
|
// (just as rustc does an autoderef and then autoref again).
|
2019-11-02 09:18:26 -05:00
|
|
|
|
2019-12-02 11:12:49 -06:00
|
|
|
// We have to be careful about the order we're looking at candidates
|
|
|
|
// in here. Consider the case where we're resolving `x.clone()`
|
|
|
|
// where `x: &Vec<_>`. This resolves to the clone method with self
|
|
|
|
// type `Vec<_>`, *not* `&_`. I.e. we need to consider methods where
|
|
|
|
// the receiver type exactly matches before cases where we have to
|
|
|
|
// do autoref. But in the autoderef steps, the `&_` self type comes
|
|
|
|
// up *before* the `Vec<_>` self type.
|
2019-11-02 09:18:26 -05:00
|
|
|
//
|
|
|
|
// On the other hand, we don't want to just pick any by-value method
|
|
|
|
// before any by-autoref method; it's just that we need to consider
|
|
|
|
// the methods by autoderef order of *receiver types*, not *self
|
|
|
|
// types*.
|
|
|
|
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
let mut table = InferenceTable::new(db, env.clone());
|
|
|
|
let ty = table.instantiate_canonical(ty.clone());
|
2023-02-27 09:01:02 -06:00
|
|
|
let deref_chain = autoderef_method_receiver(&mut table, ty);
|
2022-01-06 08:42:29 -06:00
|
|
|
|
2023-02-27 09:01:02 -06:00
|
|
|
let result = deref_chain.into_iter().try_for_each(|(receiver_ty, adj)| {
|
2021-09-11 12:49:10 -05:00
|
|
|
iterate_method_candidates_with_autoref(
|
2022-03-17 06:39:42 -05:00
|
|
|
&receiver_ty,
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
adj,
|
2019-10-31 14:01:46 -05:00
|
|
|
db,
|
2020-01-14 07:11:07 -06:00
|
|
|
env.clone(),
|
2020-01-14 07:20:33 -06:00
|
|
|
traits_in_scope,
|
2021-03-20 13:28:26 -05:00
|
|
|
visible_from_module,
|
2019-10-31 14:01:46 -05:00
|
|
|
name,
|
2020-06-24 10:45:38 -05:00
|
|
|
callback,
|
2021-12-10 13:01:24 -06:00
|
|
|
)
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
});
|
|
|
|
result
|
2019-05-01 10:57:56 -05:00
|
|
|
}
|
2019-10-31 14:01:46 -05:00
|
|
|
LookupMode::Path => {
|
|
|
|
// No autoderef for path lookups
|
2020-01-14 07:11:07 -06:00
|
|
|
iterate_method_candidates_for_self_ty(
|
2021-06-12 22:54:16 -05:00
|
|
|
ty,
|
2020-01-14 07:11:07 -06:00
|
|
|
db,
|
2022-03-12 07:35:25 -06:00
|
|
|
env,
|
2020-01-14 07:20:33 -06:00
|
|
|
traits_in_scope,
|
2021-03-20 13:48:35 -05:00
|
|
|
visible_from_module,
|
2020-01-14 07:11:07 -06:00
|
|
|
name,
|
2020-06-24 10:45:38 -05:00
|
|
|
callback,
|
2020-01-14 07:11:07 -06:00
|
|
|
)
|
2019-11-02 09:18:26 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-24 10:45:38 -05:00
|
|
|
fn iterate_method_candidates_with_autoref(
|
2022-03-17 06:39:42 -05:00
|
|
|
receiver_ty: &Canonical<Ty>,
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
first_adjustment: ReceiverAdjustments,
|
2020-03-13 10:05:46 -05:00
|
|
|
db: &dyn HirDatabase,
|
2020-01-14 07:11:07 -06:00
|
|
|
env: Arc<TraitEnvironment>,
|
|
|
|
traits_in_scope: &FxHashSet<TraitId>,
|
2022-02-01 16:29:40 -06:00
|
|
|
visible_from_module: VisibleFromModule,
|
2019-11-02 09:18:26 -05:00
|
|
|
name: Option<&Name>,
|
2022-12-30 16:56:08 -06:00
|
|
|
mut callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
|
2021-09-11 12:49:10 -05:00
|
|
|
) -> ControlFlow<()> {
|
2022-03-23 13:18:12 -05:00
|
|
|
if receiver_ty.value.is_general_var(Interner, &receiver_ty.binders) {
|
|
|
|
// don't try to resolve methods on unknown types
|
|
|
|
return ControlFlow::Continue(());
|
|
|
|
}
|
|
|
|
|
2023-02-27 09:01:02 -06:00
|
|
|
let mut iterate_method_candidates_by_receiver = move |receiver_ty, first_adjustment| {
|
2023-02-27 08:51:45 -06:00
|
|
|
iterate_method_candidates_by_receiver(
|
|
|
|
receiver_ty,
|
|
|
|
first_adjustment,
|
|
|
|
db,
|
|
|
|
env.clone(),
|
|
|
|
traits_in_scope,
|
|
|
|
visible_from_module,
|
|
|
|
name,
|
|
|
|
&mut callback,
|
|
|
|
)
|
|
|
|
};
|
|
|
|
|
|
|
|
iterate_method_candidates_by_receiver(receiver_ty, first_adjustment.clone())?;
|
2021-09-11 12:49:10 -05:00
|
|
|
|
2019-11-02 09:18:26 -05:00
|
|
|
let refed = Canonical {
|
2021-11-10 10:33:35 -06:00
|
|
|
value: TyKind::Ref(Mutability::Not, static_lifetime(), receiver_ty.value.clone())
|
2021-12-19 10:58:39 -06:00
|
|
|
.intern(Interner),
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
binders: receiver_ty.binders.clone(),
|
2019-11-02 09:18:26 -05:00
|
|
|
};
|
2021-09-11 12:49:10 -05:00
|
|
|
|
2023-02-27 08:51:45 -06:00
|
|
|
iterate_method_candidates_by_receiver(&refed, first_adjustment.with_autoref(Mutability::Not))?;
|
2021-09-11 12:49:10 -05:00
|
|
|
|
2019-11-02 09:18:26 -05:00
|
|
|
let ref_muted = Canonical {
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
value: TyKind::Ref(Mutability::Mut, static_lifetime(), receiver_ty.value.clone())
|
|
|
|
.intern(Interner),
|
|
|
|
binders: receiver_ty.binders.clone(),
|
2019-11-02 09:18:26 -05:00
|
|
|
};
|
2021-09-11 12:49:10 -05:00
|
|
|
|
|
|
|
iterate_method_candidates_by_receiver(
|
2019-12-01 15:14:28 -06:00
|
|
|
&ref_muted,
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
first_adjustment.with_autoref(Mutability::Mut),
|
2021-09-11 12:49:10 -05:00
|
|
|
)
|
2019-11-02 09:18:26 -05:00
|
|
|
}
|
|
|
|
|
2020-06-24 10:45:38 -05:00
|
|
|
fn iterate_method_candidates_by_receiver(
|
2019-11-02 09:18:26 -05:00
|
|
|
receiver_ty: &Canonical<Ty>,
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
receiver_adjustments: ReceiverAdjustments,
|
2020-03-13 10:05:46 -05:00
|
|
|
db: &dyn HirDatabase,
|
2020-01-14 07:11:07 -06:00
|
|
|
env: Arc<TraitEnvironment>,
|
|
|
|
traits_in_scope: &FxHashSet<TraitId>,
|
2022-02-01 16:29:40 -06:00
|
|
|
visible_from_module: VisibleFromModule,
|
2019-11-02 09:18:26 -05:00
|
|
|
name: Option<&Name>,
|
2022-12-30 16:56:08 -06:00
|
|
|
mut callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
|
2021-09-11 12:49:10 -05:00
|
|
|
) -> ControlFlow<()> {
|
2022-03-17 06:39:42 -05:00
|
|
|
let mut table = InferenceTable::new(db, env);
|
|
|
|
let receiver_ty = table.instantiate_canonical(receiver_ty.clone());
|
|
|
|
let snapshot = table.snapshot();
|
2019-11-02 09:18:26 -05:00
|
|
|
// We're looking for methods with *receiver* type receiver_ty. These could
|
|
|
|
// be found in any of the derefs of receiver_ty, so we have to go through
|
|
|
|
// that.
|
2022-03-17 06:39:42 -05:00
|
|
|
let mut autoderef = autoderef::Autoderef::new(&mut table, receiver_ty.clone());
|
|
|
|
while let Some((self_ty, _)) = autoderef.next() {
|
2021-09-11 12:49:10 -05:00
|
|
|
iterate_inherent_methods(
|
2022-03-17 06:39:42 -05:00
|
|
|
&self_ty,
|
2022-12-30 02:05:03 -06:00
|
|
|
autoderef.table,
|
2021-03-20 13:28:26 -05:00
|
|
|
name,
|
2022-03-17 06:39:42 -05:00
|
|
|
Some(&receiver_ty),
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
Some(receiver_adjustments.clone()),
|
2021-03-20 13:28:26 -05:00
|
|
|
visible_from_module,
|
|
|
|
&mut callback,
|
2021-09-11 12:49:10 -05:00
|
|
|
)?
|
2019-12-02 11:12:49 -06:00
|
|
|
}
|
2021-09-11 12:49:10 -05:00
|
|
|
|
2022-03-17 06:39:42 -05:00
|
|
|
table.rollback_to(snapshot);
|
|
|
|
|
|
|
|
let mut autoderef = autoderef::Autoderef::new(&mut table, receiver_ty.clone());
|
|
|
|
while let Some((self_ty, _)) = autoderef.next() {
|
2021-09-11 12:49:10 -05:00
|
|
|
iterate_trait_method_candidates(
|
2022-03-17 06:39:42 -05:00
|
|
|
&self_ty,
|
2022-12-30 02:05:03 -06:00
|
|
|
autoderef.table,
|
2021-06-12 22:54:16 -05:00
|
|
|
traits_in_scope,
|
2019-12-01 15:14:28 -06:00
|
|
|
name,
|
2022-03-17 06:39:42 -05:00
|
|
|
Some(&receiver_ty),
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
Some(receiver_adjustments.clone()),
|
2019-12-01 15:14:28 -06:00
|
|
|
&mut callback,
|
2021-09-11 12:49:10 -05:00
|
|
|
)?
|
2019-04-14 09:08:10 -05:00
|
|
|
}
|
2021-09-11 12:49:10 -05:00
|
|
|
|
|
|
|
ControlFlow::Continue(())
|
2019-05-01 10:57:56 -05:00
|
|
|
}
|
2019-04-14 09:08:10 -05:00
|
|
|
|
2020-06-24 10:45:38 -05:00
|
|
|
fn iterate_method_candidates_for_self_ty(
|
2019-11-02 09:18:26 -05:00
|
|
|
self_ty: &Canonical<Ty>,
|
2020-03-13 10:05:46 -05:00
|
|
|
db: &dyn HirDatabase,
|
2020-01-14 07:11:07 -06:00
|
|
|
env: Arc<TraitEnvironment>,
|
|
|
|
traits_in_scope: &FxHashSet<TraitId>,
|
2022-02-01 16:29:40 -06:00
|
|
|
visible_from_module: VisibleFromModule,
|
2019-11-02 09:18:26 -05:00
|
|
|
name: Option<&Name>,
|
2022-12-30 16:56:08 -06:00
|
|
|
mut callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
|
2021-09-11 12:49:10 -05:00
|
|
|
) -> ControlFlow<()> {
|
2022-03-17 06:39:42 -05:00
|
|
|
let mut table = InferenceTable::new(db, env);
|
|
|
|
let self_ty = table.instantiate_canonical(self_ty.clone());
|
2021-09-11 12:49:10 -05:00
|
|
|
iterate_inherent_methods(
|
2022-03-17 06:39:42 -05:00
|
|
|
&self_ty,
|
|
|
|
&mut table,
|
2021-05-16 08:50:28 -05:00
|
|
|
name,
|
|
|
|
None,
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
None,
|
2021-05-16 08:50:28 -05:00
|
|
|
visible_from_module,
|
|
|
|
&mut callback,
|
2021-09-11 12:49:10 -05:00
|
|
|
)?;
|
2022-03-17 06:39:42 -05:00
|
|
|
iterate_trait_method_candidates(
|
|
|
|
&self_ty,
|
|
|
|
&mut table,
|
|
|
|
traits_in_scope,
|
|
|
|
name,
|
|
|
|
None,
|
|
|
|
None,
|
|
|
|
callback,
|
|
|
|
)
|
2019-11-02 09:18:26 -05:00
|
|
|
}
|
|
|
|
|
2020-06-24 10:45:38 -05:00
|
|
|
fn iterate_trait_method_candidates(
|
2022-03-17 06:39:42 -05:00
|
|
|
self_ty: &Ty,
|
2022-07-20 08:02:08 -05:00
|
|
|
table: &mut InferenceTable<'_>,
|
2020-01-14 07:11:07 -06:00
|
|
|
traits_in_scope: &FxHashSet<TraitId>,
|
2019-05-01 10:57:56 -05:00
|
|
|
name: Option<&Name>,
|
2022-03-17 06:39:42 -05:00
|
|
|
receiver_ty: Option<&Ty>,
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
receiver_adjustments: Option<ReceiverAdjustments>,
|
2022-12-30 16:56:08 -06:00
|
|
|
callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
|
2021-09-11 12:49:10 -05:00
|
|
|
) -> ControlFlow<()> {
|
2022-03-17 06:39:42 -05:00
|
|
|
let db = table.db;
|
|
|
|
let env = table.trait_env.clone();
|
|
|
|
let self_is_array = matches!(self_ty.kind(Interner), chalk_ir::TyKind::Array(..));
|
2021-09-11 12:49:10 -05:00
|
|
|
|
2022-03-17 06:39:42 -05:00
|
|
|
let canonical_self_ty = table.canonicalize(self_ty.clone()).value;
|
|
|
|
|
2022-09-20 09:39:17 -05:00
|
|
|
'traits: for &t in traits_in_scope {
|
2019-11-26 09:00:36 -06:00
|
|
|
let data = db.trait_data(t);
|
2019-08-22 06:23:50 -05:00
|
|
|
|
2021-06-01 14:33:14 -05:00
|
|
|
// Traits annotated with `#[rustc_skip_array_during_method_dispatch]` are skipped during
|
|
|
|
// method resolution, if the receiver is an array, and we're compiling for editions before
|
|
|
|
// 2021.
|
|
|
|
// This is to make `[a].into_iter()` not break code with the new `IntoIterator` impl for
|
|
|
|
// arrays.
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
if data.skip_array_during_method_dispatch && self_is_array {
|
2021-06-01 14:33:14 -05:00
|
|
|
// FIXME: this should really be using the edition of the method name's span, in case it
|
|
|
|
// comes from a macro
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
if db.crate_graph()[env.krate].edition < Edition::Edition2021 {
|
2021-06-01 14:33:14 -05:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-01 10:57:56 -05:00
|
|
|
// we'll be lazy about checking whether the type implements the
|
|
|
|
// trait, but if we find out it doesn't, we'll skip the rest of the
|
|
|
|
// iteration
|
2019-11-15 14:00:27 -06:00
|
|
|
let mut known_implemented = false;
|
2021-12-10 13:01:24 -06:00
|
|
|
for &(_, item) in data.items.iter() {
|
2021-03-20 13:48:35 -05:00
|
|
|
// Don't pass a `visible_from_module` down to `is_valid_candidate`,
|
|
|
|
// since only inherent methods should be included into visibility checking.
|
2022-12-30 16:56:08 -06:00
|
|
|
let visible = match is_valid_candidate(table, name, receiver_ty, item, self_ty, None) {
|
|
|
|
IsValidCandidate::Yes => true,
|
|
|
|
IsValidCandidate::NotVisible => false,
|
|
|
|
IsValidCandidate::No => continue,
|
|
|
|
};
|
2019-10-31 13:28:33 -05:00
|
|
|
if !known_implemented {
|
2022-03-17 06:39:42 -05:00
|
|
|
let goal = generic_implements_goal(db, env.clone(), t, &canonical_self_ty);
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
if db.trait_solve(env.krate, goal.cast(Interner)).is_none() {
|
2019-10-31 13:28:33 -05:00
|
|
|
continue 'traits;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
known_implemented = true;
|
2022-12-30 16:56:08 -06:00
|
|
|
callback(receiver_adjustments.clone().unwrap_or_default(), item, visible)?;
|
2019-03-24 11:36:15 -05:00
|
|
|
}
|
2019-01-07 06:44:54 -06:00
|
|
|
}
|
2021-09-11 12:49:10 -05:00
|
|
|
ControlFlow::Continue(())
|
2019-05-01 10:57:56 -05:00
|
|
|
}
|
2019-01-07 06:44:54 -06:00
|
|
|
|
2020-06-24 10:45:38 -05:00
|
|
|
fn iterate_inherent_methods(
|
2022-03-17 06:39:42 -05:00
|
|
|
self_ty: &Ty,
|
2022-07-20 08:02:08 -05:00
|
|
|
table: &mut InferenceTable<'_>,
|
2019-05-01 10:57:56 -05:00
|
|
|
name: Option<&Name>,
|
2022-03-17 06:39:42 -05:00
|
|
|
receiver_ty: Option<&Ty>,
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
receiver_adjustments: Option<ReceiverAdjustments>,
|
2022-02-01 16:29:40 -06:00
|
|
|
visible_from_module: VisibleFromModule,
|
2022-12-30 16:56:08 -06:00
|
|
|
callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
|
2021-09-11 12:49:10 -05:00
|
|
|
) -> ControlFlow<()> {
|
2022-03-17 06:39:42 -05:00
|
|
|
let db = table.db;
|
|
|
|
let env = table.trait_env.clone();
|
2022-09-20 09:39:17 -05:00
|
|
|
|
|
|
|
// For trait object types and placeholder types with trait bounds, the methods of the trait and
|
|
|
|
// its super traits are considered inherent methods. This matters because these methods have
|
|
|
|
// higher priority than the other traits' methods, which would be considered in
|
|
|
|
// `iterate_trait_method_candidates()` only after this function.
|
|
|
|
match self_ty.kind(Interner) {
|
|
|
|
TyKind::Placeholder(_) => {
|
|
|
|
let env = table.trait_env.clone();
|
|
|
|
let traits = env
|
|
|
|
.traits_in_scope_from_clauses(self_ty.clone())
|
|
|
|
.flat_map(|t| all_super_traits(db.upcast(), t));
|
|
|
|
iterate_inherent_trait_methods(
|
|
|
|
self_ty,
|
|
|
|
table,
|
|
|
|
name,
|
|
|
|
receiver_ty,
|
|
|
|
receiver_adjustments.clone(),
|
|
|
|
callback,
|
|
|
|
traits,
|
|
|
|
)?;
|
|
|
|
}
|
|
|
|
TyKind::Dyn(_) => {
|
|
|
|
if let Some(principal_trait) = self_ty.dyn_trait() {
|
|
|
|
let traits = all_super_traits(db.upcast(), principal_trait);
|
|
|
|
iterate_inherent_trait_methods(
|
|
|
|
self_ty,
|
|
|
|
table,
|
|
|
|
name,
|
|
|
|
receiver_ty,
|
|
|
|
receiver_adjustments.clone(),
|
|
|
|
callback,
|
|
|
|
traits.into_iter(),
|
|
|
|
)?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_ => {}
|
|
|
|
}
|
|
|
|
|
2022-03-17 06:39:42 -05:00
|
|
|
let def_crates = match def_crates(db, self_ty, env.krate) {
|
2020-06-24 10:45:38 -05:00
|
|
|
Some(k) => k,
|
2021-09-11 12:49:10 -05:00
|
|
|
None => return ControlFlow::Continue(()),
|
2020-06-24 10:45:38 -05:00
|
|
|
};
|
2021-09-11 12:49:10 -05:00
|
|
|
|
2023-01-06 04:52:41 -06:00
|
|
|
let (module, mut block) = match visible_from_module {
|
2022-02-01 16:29:40 -06:00
|
|
|
VisibleFromModule::Filter(module) => (Some(module), module.containing_block()),
|
|
|
|
VisibleFromModule::IncludeBlock(block) => (None, Some(block)),
|
|
|
|
VisibleFromModule::None => (None, None),
|
|
|
|
};
|
|
|
|
|
2023-01-06 04:52:41 -06:00
|
|
|
while let Some(block_id) = block {
|
2022-02-01 16:29:40 -06:00
|
|
|
if let Some(impls) = db.inherent_impls_in_block(block_id) {
|
|
|
|
impls_for_self_ty(
|
|
|
|
&impls,
|
|
|
|
self_ty,
|
2022-03-17 06:39:42 -05:00
|
|
|
table,
|
2022-02-01 16:29:40 -06:00
|
|
|
name,
|
|
|
|
receiver_ty,
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
receiver_adjustments.clone(),
|
2022-02-01 16:29:40 -06:00
|
|
|
module,
|
|
|
|
callback,
|
|
|
|
)?;
|
2021-11-09 04:13:42 -06:00
|
|
|
}
|
2023-01-06 04:52:41 -06:00
|
|
|
|
|
|
|
block = db
|
|
|
|
.block_def_map(block_id)
|
|
|
|
.and_then(|map| map.parent())
|
|
|
|
.and_then(|module| module.containing_block());
|
2021-11-09 04:13:42 -06:00
|
|
|
}
|
|
|
|
|
2020-06-24 10:45:38 -05:00
|
|
|
for krate in def_crates {
|
2020-07-01 10:15:20 -05:00
|
|
|
let impls = db.inherent_impls_in_crate(krate);
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
impls_for_self_ty(
|
|
|
|
&impls,
|
|
|
|
self_ty,
|
2022-03-17 06:39:42 -05:00
|
|
|
table,
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
name,
|
|
|
|
receiver_ty,
|
|
|
|
receiver_adjustments.clone(),
|
|
|
|
module,
|
|
|
|
callback,
|
|
|
|
)?;
|
2021-11-09 04:13:42 -06:00
|
|
|
}
|
|
|
|
return ControlFlow::Continue(());
|
2019-01-07 06:44:54 -06:00
|
|
|
|
2022-09-20 09:39:17 -05:00
|
|
|
fn iterate_inherent_trait_methods(
|
|
|
|
self_ty: &Ty,
|
|
|
|
table: &mut InferenceTable<'_>,
|
|
|
|
name: Option<&Name>,
|
|
|
|
receiver_ty: Option<&Ty>,
|
|
|
|
receiver_adjustments: Option<ReceiverAdjustments>,
|
2022-12-30 16:56:08 -06:00
|
|
|
callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
|
2022-09-20 09:39:17 -05:00
|
|
|
traits: impl Iterator<Item = TraitId>,
|
|
|
|
) -> ControlFlow<()> {
|
|
|
|
let db = table.db;
|
|
|
|
for t in traits {
|
|
|
|
let data = db.trait_data(t);
|
|
|
|
for &(_, item) in data.items.iter() {
|
|
|
|
// We don't pass `visible_from_module` as all trait items should be visible.
|
2022-12-30 16:56:08 -06:00
|
|
|
let visible =
|
|
|
|
match is_valid_candidate(table, name, receiver_ty, item, self_ty, None) {
|
|
|
|
IsValidCandidate::Yes => true,
|
|
|
|
IsValidCandidate::NotVisible => false,
|
|
|
|
IsValidCandidate::No => continue,
|
|
|
|
};
|
|
|
|
callback(receiver_adjustments.clone().unwrap_or_default(), item, visible)?;
|
2022-09-20 09:39:17 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
ControlFlow::Continue(())
|
|
|
|
}
|
|
|
|
|
2021-11-09 04:13:42 -06:00
|
|
|
fn impls_for_self_ty(
|
|
|
|
impls: &InherentImpls,
|
2022-03-17 06:39:42 -05:00
|
|
|
self_ty: &Ty,
|
2022-07-20 08:02:08 -05:00
|
|
|
table: &mut InferenceTable<'_>,
|
2021-11-09 04:13:42 -06:00
|
|
|
name: Option<&Name>,
|
2022-03-17 06:39:42 -05:00
|
|
|
receiver_ty: Option<&Ty>,
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
receiver_adjustments: Option<ReceiverAdjustments>,
|
2021-11-09 04:13:42 -06:00
|
|
|
visible_from_module: Option<ModuleId>,
|
2022-12-30 16:56:08 -06:00
|
|
|
callback: &mut dyn FnMut(ReceiverAdjustments, AssocItemId, bool) -> ControlFlow<()>,
|
2021-11-09 04:13:42 -06:00
|
|
|
) -> ControlFlow<()> {
|
2022-03-17 06:39:42 -05:00
|
|
|
let db = table.db;
|
|
|
|
let impls_for_self_ty = impls.for_self_ty(self_ty);
|
2021-09-08 03:13:29 -05:00
|
|
|
for &impl_def in impls_for_self_ty {
|
2021-11-10 10:33:35 -06:00
|
|
|
for &item in &db.impl_data(impl_def).items {
|
2022-12-30 16:56:08 -06:00
|
|
|
let visible = match is_valid_candidate(
|
|
|
|
table,
|
|
|
|
name,
|
|
|
|
receiver_ty,
|
|
|
|
item,
|
|
|
|
self_ty,
|
|
|
|
visible_from_module,
|
|
|
|
) {
|
|
|
|
IsValidCandidate::Yes => true,
|
|
|
|
IsValidCandidate::NotVisible => false,
|
|
|
|
IsValidCandidate::No => continue,
|
|
|
|
};
|
|
|
|
callback(receiver_adjustments.clone().unwrap_or_default(), item, visible)?;
|
2019-01-07 06:44:54 -06:00
|
|
|
}
|
|
|
|
}
|
2021-11-09 04:13:42 -06:00
|
|
|
ControlFlow::Continue(())
|
2019-01-07 06:44:54 -06:00
|
|
|
}
|
2019-05-01 10:57:56 -05:00
|
|
|
}
|
2019-02-12 02:33:23 -06:00
|
|
|
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
/// Returns the receiver type for the index trait call.
|
2020-02-29 15:48:23 -06:00
|
|
|
pub fn resolve_indexing_op(
|
2020-03-13 10:05:46 -05:00
|
|
|
db: &dyn HirDatabase,
|
2020-02-29 15:48:23 -06:00
|
|
|
env: Arc<TraitEnvironment>,
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
ty: Canonical<Ty>,
|
2020-02-29 15:48:23 -06:00
|
|
|
index_trait: TraitId,
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
) -> Option<ReceiverAdjustments> {
|
|
|
|
let mut table = InferenceTable::new(db, env.clone());
|
|
|
|
let ty = table.instantiate_canonical(ty);
|
2023-02-27 09:01:02 -06:00
|
|
|
let deref_chain = autoderef_method_receiver(&mut table, ty);
|
|
|
|
for (ty, adj) in deref_chain {
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
let goal = generic_implements_goal(db, env.clone(), index_trait, &ty);
|
|
|
|
if db.trait_solve(env.krate, goal.cast(Interner)).is_some() {
|
|
|
|
return Some(adj);
|
2020-02-29 15:48:23 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
None
|
|
|
|
}
|
2022-06-23 07:10:12 -05:00
|
|
|
|
2022-08-23 02:05:52 -05:00
|
|
|
macro_rules! check_that {
|
|
|
|
($cond:expr) => {
|
|
|
|
if !$cond {
|
2022-12-30 16:56:08 -06:00
|
|
|
return IsValidCandidate::No;
|
2022-08-23 02:05:52 -05:00
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2022-06-23 07:10:12 -05:00
|
|
|
fn is_valid_candidate(
|
2022-07-20 08:02:08 -05:00
|
|
|
table: &mut InferenceTable<'_>,
|
2022-06-23 07:10:12 -05:00
|
|
|
name: Option<&Name>,
|
|
|
|
receiver_ty: Option<&Ty>,
|
|
|
|
item: AssocItemId,
|
|
|
|
self_ty: &Ty,
|
|
|
|
visible_from_module: Option<ModuleId>,
|
2022-12-30 16:56:08 -06:00
|
|
|
) -> IsValidCandidate {
|
2022-06-23 07:10:12 -05:00
|
|
|
let db = table.db;
|
|
|
|
match item {
|
|
|
|
AssocItemId::FunctionId(m) => {
|
2022-08-23 02:05:52 -05:00
|
|
|
is_valid_fn_candidate(table, m, name, receiver_ty, self_ty, visible_from_module)
|
2022-06-23 07:10:12 -05:00
|
|
|
}
|
|
|
|
AssocItemId::ConstId(c) => {
|
|
|
|
let data = db.const_data(c);
|
|
|
|
check_that!(receiver_ty.is_none());
|
|
|
|
|
|
|
|
check_that!(name.map_or(true, |n| data.name.as_ref() == Some(n)));
|
2022-12-30 16:56:08 -06:00
|
|
|
|
|
|
|
if let Some(from_module) = visible_from_module {
|
|
|
|
if !db.const_visibility(c).is_visible_from(db.upcast(), from_module) {
|
2022-06-23 07:10:12 -05:00
|
|
|
cov_mark::hit!(const_candidate_not_visible);
|
2022-12-30 16:56:08 -06:00
|
|
|
return IsValidCandidate::NotVisible;
|
2022-06-23 07:10:12 -05:00
|
|
|
}
|
2022-12-30 16:56:08 -06:00
|
|
|
}
|
2022-06-23 07:10:12 -05:00
|
|
|
if let ItemContainerId::ImplId(impl_id) = c.lookup(db.upcast()).container {
|
|
|
|
let self_ty_matches = table.run_in_snapshot(|table| {
|
2022-10-11 02:37:35 -05:00
|
|
|
let expected_self_ty = TyBuilder::impl_self_ty(db, impl_id)
|
|
|
|
.fill_with_inference_vars(table)
|
|
|
|
.build();
|
2022-12-30 02:05:03 -06:00
|
|
|
table.unify(&expected_self_ty, self_ty)
|
2022-06-23 07:10:12 -05:00
|
|
|
});
|
|
|
|
if !self_ty_matches {
|
|
|
|
cov_mark::hit!(const_candidate_self_type_mismatch);
|
2022-12-30 16:56:08 -06:00
|
|
|
return IsValidCandidate::No;
|
2022-06-23 07:10:12 -05:00
|
|
|
}
|
2021-03-20 13:28:26 -05:00
|
|
|
}
|
2022-12-30 16:56:08 -06:00
|
|
|
IsValidCandidate::Yes
|
2019-10-31 14:37:46 -05:00
|
|
|
}
|
2022-12-30 16:56:08 -06:00
|
|
|
_ => IsValidCandidate::No,
|
2019-10-31 14:37:46 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-30 16:56:08 -06:00
|
|
|
enum IsValidCandidate {
|
|
|
|
Yes,
|
|
|
|
No,
|
|
|
|
NotVisible,
|
|
|
|
}
|
|
|
|
|
2022-08-23 02:05:52 -05:00
|
|
|
fn is_valid_fn_candidate(
|
|
|
|
table: &mut InferenceTable<'_>,
|
|
|
|
fn_id: FunctionId,
|
|
|
|
name: Option<&Name>,
|
|
|
|
receiver_ty: Option<&Ty>,
|
|
|
|
self_ty: &Ty,
|
|
|
|
visible_from_module: Option<ModuleId>,
|
2022-12-30 16:56:08 -06:00
|
|
|
) -> IsValidCandidate {
|
2022-08-23 02:05:52 -05:00
|
|
|
let db = table.db;
|
|
|
|
let data = db.function_data(fn_id);
|
|
|
|
|
|
|
|
check_that!(name.map_or(true, |n| n == &data.name));
|
2022-12-30 16:56:08 -06:00
|
|
|
if let Some(from_module) = visible_from_module {
|
|
|
|
if !db.function_visibility(fn_id).is_visible_from(db.upcast(), from_module) {
|
2022-08-23 02:05:52 -05:00
|
|
|
cov_mark::hit!(autoderef_candidate_not_visible);
|
2022-12-30 16:56:08 -06:00
|
|
|
return IsValidCandidate::NotVisible;
|
2022-08-23 02:05:52 -05:00
|
|
|
}
|
2022-12-30 16:56:08 -06:00
|
|
|
}
|
2022-08-23 02:05:52 -05:00
|
|
|
table.run_in_snapshot(|table| {
|
|
|
|
let container = fn_id.lookup(db.upcast()).container;
|
2022-10-11 02:37:35 -05:00
|
|
|
let (impl_subst, expect_self_ty) = match container {
|
2022-08-23 02:05:52 -05:00
|
|
|
ItemContainerId::ImplId(it) => {
|
2022-10-11 02:37:35 -05:00
|
|
|
let subst =
|
|
|
|
TyBuilder::subst_for_def(db, it, None).fill_with_inference_vars(table).build();
|
|
|
|
let self_ty = db.impl_self_ty(it).substitute(Interner, &subst);
|
|
|
|
(subst, self_ty)
|
2022-08-23 02:05:52 -05:00
|
|
|
}
|
|
|
|
ItemContainerId::TraitId(it) => {
|
2022-10-11 02:37:35 -05:00
|
|
|
let subst =
|
|
|
|
TyBuilder::subst_for_def(db, it, None).fill_with_inference_vars(table).build();
|
|
|
|
let self_ty = subst.at(Interner, 0).assert_ty_ref(Interner).clone();
|
|
|
|
(subst, self_ty)
|
2022-08-23 02:05:52 -05:00
|
|
|
}
|
|
|
|
_ => unreachable!(),
|
|
|
|
};
|
|
|
|
|
2022-10-11 02:37:35 -05:00
|
|
|
let fn_subst = TyBuilder::subst_for_def(db, fn_id, Some(impl_subst.clone()))
|
2022-08-23 02:05:52 -05:00
|
|
|
.fill_with_inference_vars(table)
|
|
|
|
.build();
|
|
|
|
|
|
|
|
check_that!(table.unify(&expect_self_ty, self_ty));
|
|
|
|
|
|
|
|
if let Some(receiver_ty) = receiver_ty {
|
|
|
|
check_that!(data.has_self_param());
|
|
|
|
|
|
|
|
let sig = db.callable_item_signature(fn_id.into());
|
|
|
|
let expected_receiver =
|
|
|
|
sig.map(|s| s.params()[0].clone()).substitute(Interner, &fn_subst);
|
|
|
|
|
2022-11-01 04:31:31 -05:00
|
|
|
check_that!(table.unify(receiver_ty, &expected_receiver));
|
2022-08-23 02:05:52 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
if let ItemContainerId::ImplId(impl_id) = container {
|
|
|
|
// We need to consider the bounds on the impl to distinguish functions of the same name
|
|
|
|
// for a type.
|
|
|
|
let predicates = db.generic_predicates(impl_id.into());
|
2022-12-30 16:56:08 -06:00
|
|
|
let valid = predicates
|
2022-08-23 02:05:52 -05:00
|
|
|
.iter()
|
|
|
|
.map(|predicate| {
|
|
|
|
let (p, b) = predicate
|
|
|
|
.clone()
|
|
|
|
.substitute(Interner, &impl_subst)
|
|
|
|
// Skipping the inner binders is ok, as we don't handle quantified where
|
|
|
|
// clauses yet.
|
|
|
|
.into_value_and_skipped_binders();
|
|
|
|
stdx::always!(b.len(Interner) == 0);
|
|
|
|
p
|
|
|
|
})
|
|
|
|
// It's ok to get ambiguity here, as we may not have enough information to prove
|
|
|
|
// obligations. We'll check if the user is calling the selected method properly
|
|
|
|
// later anyway.
|
2022-12-30 16:56:08 -06:00
|
|
|
.all(|p| table.try_obligation(p.cast(Interner)).is_some());
|
|
|
|
match valid {
|
|
|
|
true => IsValidCandidate::Yes,
|
|
|
|
false => IsValidCandidate::No,
|
|
|
|
}
|
2022-08-23 02:05:52 -05:00
|
|
|
} else {
|
|
|
|
// For `ItemContainerId::TraitId`, we check if `self_ty` implements the trait in
|
|
|
|
// `iterate_trait_method_candidates()`.
|
|
|
|
// For others, this function shouldn't be called.
|
2022-12-30 16:56:08 -06:00
|
|
|
IsValidCandidate::Yes
|
2022-08-23 02:05:52 -05:00
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2019-11-27 08:46:02 -06:00
|
|
|
pub fn implements_trait(
|
2019-08-02 13:16:20 -05:00
|
|
|
ty: &Canonical<Ty>,
|
2020-03-13 10:05:46 -05:00
|
|
|
db: &dyn HirDatabase,
|
2020-01-14 04:27:00 -06:00
|
|
|
env: Arc<TraitEnvironment>,
|
2019-11-26 09:00:36 -06:00
|
|
|
trait_: TraitId,
|
2019-08-02 13:16:20 -05:00
|
|
|
) -> bool {
|
2022-03-12 06:04:13 -06:00
|
|
|
let goal = generic_implements_goal(db, env.clone(), trait_, ty);
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
let solution = db.trait_solve(env.krate, goal.cast(Interner));
|
2019-08-02 13:15:43 -05:00
|
|
|
|
2019-08-02 13:56:27 -05:00
|
|
|
solution.is_some()
|
2019-08-02 13:15:43 -05:00
|
|
|
}
|
|
|
|
|
2020-10-26 13:20:33 -05:00
|
|
|
pub fn implements_trait_unique(
|
|
|
|
ty: &Canonical<Ty>,
|
|
|
|
db: &dyn HirDatabase,
|
|
|
|
env: Arc<TraitEnvironment>,
|
|
|
|
trait_: TraitId,
|
|
|
|
) -> bool {
|
2022-03-12 06:04:13 -06:00
|
|
|
let goal = generic_implements_goal(db, env.clone(), trait_, ty);
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
let solution = db.trait_solve(env.krate, goal.cast(Interner));
|
2020-10-26 13:20:33 -05:00
|
|
|
|
2021-04-04 13:27:40 -05:00
|
|
|
matches!(solution, Some(crate::Solution::Unique(_)))
|
2020-10-26 13:20:33 -05:00
|
|
|
}
|
|
|
|
|
2019-04-09 15:04:59 -05:00
|
|
|
/// This creates Substs for a trait with the given Self type and type variables
|
2019-04-20 05:34:36 -05:00
|
|
|
/// for all other parameters, to query Chalk with it.
|
2019-07-08 14:43:52 -05:00
|
|
|
fn generic_implements_goal(
|
2020-03-13 10:05:46 -05:00
|
|
|
db: &dyn HirDatabase,
|
2019-07-09 14:34:23 -05:00
|
|
|
env: Arc<TraitEnvironment>,
|
2019-11-26 09:00:36 -06:00
|
|
|
trait_: TraitId,
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
self_ty: &Canonical<Ty>,
|
2021-03-20 05:23:59 -05:00
|
|
|
) -> Canonical<InEnvironment<super::DomainGoal>> {
|
2021-03-21 14:05:38 -05:00
|
|
|
let mut kinds = self_ty.binders.interned().to_vec();
|
2021-04-03 14:50:52 -05:00
|
|
|
let trait_ref = TyBuilder::trait_ref(db, trait_)
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
.push(self_ty.value.clone())
|
2020-06-28 14:17:27 -05:00
|
|
|
.fill_with_bound_vars(DebruijnIndex::INNERMOST, kinds.len())
|
2019-09-26 14:37:03 -05:00
|
|
|
.build();
|
2022-03-09 12:50:24 -06:00
|
|
|
kinds.extend(trait_ref.substitution.iter(Interner).skip(1).map(|x| {
|
|
|
|
let vk = match x.data(Interner) {
|
|
|
|
chalk_ir::GenericArgData::Ty(_) => {
|
|
|
|
chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General)
|
|
|
|
}
|
|
|
|
chalk_ir::GenericArgData::Lifetime(_) => chalk_ir::VariableKind::Lifetime,
|
|
|
|
chalk_ir::GenericArgData::Const(c) => {
|
|
|
|
chalk_ir::VariableKind::Const(c.data(Interner).ty.clone())
|
|
|
|
}
|
|
|
|
};
|
|
|
|
chalk_ir::WithKind::new(vk, UniverseIndex::ROOT)
|
|
|
|
}));
|
2021-12-19 10:58:39 -06:00
|
|
|
let obligation = trait_ref.cast(Interner);
|
2021-03-21 14:05:38 -05:00
|
|
|
Canonical {
|
2021-12-19 10:58:39 -06:00
|
|
|
binders: CanonicalVarKinds::from_iter(Interner, kinds),
|
2021-04-07 13:48:58 -05:00
|
|
|
value: InEnvironment::new(&env.env, obligation),
|
2021-03-21 14:05:38 -05:00
|
|
|
}
|
2019-03-31 13:02:16 -05:00
|
|
|
}
|
2020-02-29 15:01:36 -06:00
|
|
|
|
|
|
|
fn autoderef_method_receiver(
|
2022-07-20 08:02:08 -05:00
|
|
|
table: &mut InferenceTable<'_>,
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
ty: Ty,
|
2023-02-27 09:01:02 -06:00
|
|
|
) -> Vec<(Canonical<Ty>, ReceiverAdjustments)> {
|
|
|
|
let mut deref_chain: Vec<_> = Vec::new();
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
let mut autoderef = autoderef::Autoderef::new(table, ty);
|
|
|
|
while let Some((ty, derefs)) = autoderef.next() {
|
2023-02-27 09:01:02 -06:00
|
|
|
deref_chain.push((
|
|
|
|
autoderef.table.canonicalize(ty).value,
|
|
|
|
ReceiverAdjustments { autoref: None, autoderefs: derefs, unsize_array: false },
|
|
|
|
));
|
Refactor autoderef and method resolution
- don't return the receiver type from method resolution; instead just
return the autorefs/autoderefs that happened and repeat them. This
ensures all the effects like trait obligations and whatever we learned
about type variables from derefing them are actually applied. Also, it
allows us to get rid of `decanonicalize_ty`, which was just wrong in
principle.
- Autoderef itself now directly works with an inference table. Sadly
this has the effect of making it harder to use as an iterator, often
requiring manual `while let` loops. (rustc works around this by using
inner mutability in the inference context, so that things like unifying
types don't require a unique reference.)
- We now record the adjustments (autoref/deref) for method receivers
and index expressions, which we didn't before.
- Removed the redundant crate parameter from method resolution, since
the trait_env contains the crate as well.
- in the HIR API, the methods now take a scope to determine the trait env.
`Type` carries a trait env, but I think that's probably a bad decision
because it's easy to create it with the wrong env, e.g. by using
`Adt::ty`. This mostly didn't matter so far because
`iterate_method_candidates` took a crate parameter and ignored
`self.krate`, but the trait env would still have been wrong in those
cases, which I think would give some wrong results in some edge cases.
Fixes #10058.
2022-02-16 10:44:03 -06:00
|
|
|
}
|
2020-02-29 15:01:36 -06:00
|
|
|
// As a last step, we can do array unsizing (that's the only unsizing that rustc does for method receivers!)
|
2023-02-27 09:01:02 -06:00
|
|
|
if let Some((TyKind::Array(parameters, _), binders, adj)) =
|
|
|
|
deref_chain.last().map(|(ty, adj)| (ty.value.kind(Interner), ty.binders.clone(), adj))
|
|
|
|
{
|
2021-12-19 10:58:39 -06:00
|
|
|
let unsized_ty = TyKind::Slice(parameters.clone()).intern(Interner);
|
2023-02-27 09:01:02 -06:00
|
|
|
deref_chain.push((
|
|
|
|
Canonical { value: unsized_ty, binders },
|
|
|
|
ReceiverAdjustments { unsize_array: true, ..adj.clone() },
|
|
|
|
));
|
2020-02-29 15:01:36 -06:00
|
|
|
}
|
2023-02-27 09:01:02 -06:00
|
|
|
deref_chain
|
2020-02-29 15:01:36 -06:00
|
|
|
}
|