rust/crates/hir_ty/src/method_resolution.rs

954 lines
34 KiB
Rust
Raw Normal View History

//! 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)
//! and the corresponding code mostly in librustc_typeck/check/method/probe.rs.
use std::{iter, sync::Arc};
2019-06-24 12:17:44 -05:00
use arrayvec::ArrayVec;
use base_db::{CrateId, Edition};
2021-04-08 07:35:15 -05:00
use chalk_ir::{cast::Cast, Mutability, UniverseIndex};
2019-11-26 06:27:33 -06:00
use hir_def::{
lang_item::LangItemTarget, nameres::DefMap, AssocContainerId, AssocItemId, FunctionId,
GenericDefId, HasModule, ImplId, Lookup, 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};
use crate::{
autoderef,
db::HirDatabase,
2021-03-13 10:23:19 -06:00
from_foreign_def_id,
2021-02-28 03:58:34 -06:00
primitive::{self, FloatTy, IntTy, UintTy},
static_lifetime,
utils::all_super_traits,
AdtId, Canonical, CanonicalVarKinds, DebruijnIndex, ForeignDefId, InEnvironment, Interner,
Scalar, Substitution, TraitEnvironment, TraitRefExt, Ty, TyBuilder, TyExt, TyKind,
};
/// This is used as a key for indexing impls.
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum TyFingerprint {
// These are lang item impls:
2021-02-28 12:13:37 -06:00
Str,
Slice,
Array,
Never,
RawPtr(Mutability),
Scalar(Scalar),
// These can have user-defined impls:
2021-03-01 14:57:39 -06:00
Adt(hir_def::AdtId),
Dyn(TraitId),
2021-03-13 10:23:19 -06:00
ForeignType(ForeignDefId),
// These only exist for trait impls
Unit,
Unnameable,
Function(u32),
}
impl TyFingerprint {
/// 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-04-05 15:23:16 -05:00
let fp = match ty.kind(&Interner) {
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)
}
/// Creates a TyFingerprint for looking up a trait impl.
pub fn for_trait_impl(ty: &Ty) -> Option<TyFingerprint> {
let fp = match ty.kind(&Interner) {
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)?,
TyKind::Ref(_, _, ty) => return TyFingerprint::for_trait_impl(ty),
TyKind::Tuple(_, subst) => {
let first_ty = subst.interned().get(0).map(|arg| arg.assert_ty_ref(&Interner));
if let Some(ty) = first_ty {
return TyFingerprint::for_trait_impl(ty);
} else {
TyFingerprint::Unit
}
}
TyKind::AssociatedType(_, _)
| TyKind::OpaqueType(_, _)
| TyKind::FnDef(_, _)
| TyKind::Closure(_, _)
| TyKind::Generator(..)
| TyKind::GeneratorWitness(..) => TyFingerprint::Unnameable,
TyKind::Function(fn_ptr) => {
TyFingerprint::Function(fn_ptr.substitution.0.len(&Interner) as u32)
}
TyKind::Alias(_)
| TyKind::Placeholder(_)
| TyKind::BoundVar(_)
| TyKind::InferenceVar(_, _)
| TyKind::Error => return None,
};
Some(fp)
}
}
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)),
];
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)),
];
/// 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>>>,
}
impl TraitImpls {
pub(crate) fn trait_impls_in_crate_query(db: &dyn HirDatabase, krate: CrateId) -> Arc<Self> {
2020-08-12 09:32:36 -05:00
let _p = profile::span("trait_impls_in_crate_query");
let mut impls = Self { map: FxHashMap::default() };
2019-11-26 06:27:33 -06:00
let crate_def_map = db.crate_def_map(krate);
collect_def_map(db, &crate_def_map, &mut impls);
return Arc::new(impls);
fn collect_def_map(db: &dyn HirDatabase, def_map: &DefMap, impls: &mut TraitImpls) {
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());
impls
.map
.entry(target_trait)
.or_default()
.entry(self_ty_fp)
.or_default()
.push(impl_id);
}
// To better support custom derives, collect impls in all unnamed const items.
// const _: () = { ... };
for konst in module_data.scope.unnamed_consts() {
let body = db.body(konst.into());
for (_, block_def_map) in body.blocks(db.upcast()) {
collect_def_map(db, &block_def_map, impls);
}
}
}
}
}
pub(crate) fn trait_impls_in_deps_query(db: &dyn HirDatabase, krate: CrateId) -> Arc<Self> {
2020-08-12 09:32:36 -05:00
let _p = profile::span("trait_impls_in_deps_query");
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));
}
Arc::new(res)
}
2020-06-19 17:36:02 -05:00
fn merge(&mut self, other: &Self) {
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 {
let vec = map.entry(*fp).or_default();
vec.extend(impls);
}
}
}
/// Queries all trait impls for the given type.
pub fn for_self_ty_without_blanket_impls(
&self,
fp: TyFingerprint,
) -> impl Iterator<Item = ImplId> + '_ {
self.map
.values()
.flat_map(move |impls| impls.get(&Some(fp)).into_iter())
.flat_map(|it| it.iter().copied())
}
/// Queries all impls of the given trait.
pub fn for_trait(&self, trait_: TraitId) -> impl Iterator<Item = ImplId> + '_ {
self.map
.get(&trait_)
.into_iter()
.flat_map(|map| map.values().flat_map(|v| v.iter().copied()))
}
/// Queries all impls of `trait_` that may apply to `self_ty`.
pub fn for_trait_and_self_ty(
&self,
trait_: TraitId,
self_ty: TyFingerprint,
) -> impl Iterator<Item = ImplId> + '_ {
self.map
.get(&trait_)
.into_iter()
.flat_map(move |map| map.get(&None).into_iter().chain(map.get(&Some(self_ty))))
.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>>,
}
impl InherentImpls {
pub(crate) fn inherent_impls_in_crate_query(db: &dyn HirDatabase, krate: CrateId) -> Arc<Self> {
let mut impls = Self { map: FxHashMap::default() };
let crate_def_map = db.crate_def_map(krate);
collect_def_map(db, &crate_def_map, &mut impls);
return Arc::new(impls);
fn collect_def_map(db: &dyn HirDatabase, def_map: &DefMap, impls: &mut InherentImpls) {
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;
}
let self_ty = db.impl_self_ty(impl_id);
let fp = TyFingerprint::for_inherent_impl(self_ty.skip_binders());
if let Some(fp) = fp {
impls.map.entry(fp).or_default().push(impl_id);
}
// `fp` should only be `None` in error cases (either erroneous code or incomplete name resolution)
}
// To better support custom derives, collect impls in all unnamed const items.
// const _: () = { ... };
for konst in module_data.scope.unnamed_consts() {
let body = db.body(konst.into());
for (_, block_def_map) in body.blocks(db.upcast()) {
collect_def_map(db, &block_def_map, impls);
}
}
}
}
}
pub fn for_self_ty(&self, self_ty: &Ty) -> &[ImplId] {
match TyFingerprint::for_inherent_impl(self_ty) {
Some(fp) => self.map.get(&fp).map(|vec| vec.as_ref()).unwrap_or(&[]),
None => &[],
}
}
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
}
}
2021-04-07 06:09:31 -05:00
pub fn def_crates(
db: &dyn HirDatabase,
ty: &Ty,
cur_crate: CrateId,
) -> Option<ArrayVec<CrateId, 2>> {
// Types like slice can have inherent impls in several crates, (core and alloc).
// The corresponding impls are marked with lang items, so we can use them to find the required crates.
macro_rules! lang_item_crate {
2020-03-22 08:44:38 -05:00
($($name:expr),+ $(,)?) => {{
2021-03-25 14:03:20 -05:00
let mut v = ArrayVec::<LangItemTarget, 2>::new();
2020-03-22 08:44:38 -05:00
$(
v.extend(db.lang_item(cur_crate, $name.into()));
)+
v
}};
}
2019-06-24 12:17:44 -05:00
2021-04-07 06:09:31 -05:00
let mod_to_crate_ids = |module: ModuleId| Some(std::iter::once(module.krate()).collect());
2021-04-07 06:09:31 -05:00
let lang_item_targets = match ty.kind(&Interner) {
TyKind::Adt(AdtId(def_id), _) => {
return mod_to_crate_ids(def_id.module(db.upcast()));
}
TyKind::Foreign(id) => {
return mod_to_crate_ids(
from_foreign_def_id(*id).lookup(db.upcast()).module(db.upcast()),
);
}
TyKind::Scalar(Scalar::Bool) => lang_item_crate!("bool"),
TyKind::Scalar(Scalar::Char) => lang_item_crate!("char"),
TyKind::Scalar(Scalar::Float(f)) => match f {
// There are two lang items: one in libcore (fXX) and one in libstd (fXX_runtime)
FloatTy::F32 => lang_item_crate!("f32", "f32_runtime"),
FloatTy::F64 => lang_item_crate!("f64", "f64_runtime"),
},
&TyKind::Scalar(Scalar::Int(t)) => {
lang_item_crate!(primitive::int_ty_to_string(t))
}
&TyKind::Scalar(Scalar::Uint(t)) => {
lang_item_crate!(primitive::uint_ty_to_string(t))
}
TyKind::Str => lang_item_crate!("str_alloc", "str"),
TyKind::Slice(_) => lang_item_crate!("slice_alloc", "slice"),
TyKind::Raw(Mutability::Not, _) => lang_item_crate!("const_ptr"),
TyKind::Raw(Mutability::Mut, _) => lang_item_crate!("mut_ptr"),
TyKind::Dyn(_) => {
return ty.dyn_trait().and_then(|trait_| {
mod_to_crate_ids(GenericDefId::TraitId(trait_).module(db.upcast()))
});
}
_ => return None,
};
let res = lang_item_targets
.into_iter()
.filter_map(|it| match it {
LangItemTarget::ImplDefId(it) => Some(it),
_ => None,
})
.map(|it| it.lookup(db.upcast()).container.krate())
.collect();
Some(res)
}
/// Look up the method with the given name, returning the actual autoderefed
/// receiver type (but without autoref applied yet).
pub(crate) fn lookup_method(
ty: &Canonical<Ty>,
db: &dyn HirDatabase,
2020-01-14 07:20:33 -06:00
env: Arc<TraitEnvironment>,
krate: CrateId,
traits_in_scope: &FxHashSet<TraitId>,
visible_from_module: Option<ModuleId>,
name: &Name,
2019-11-27 06:56:20 -06:00
) -> Option<(Ty, FunctionId)> {
2020-01-14 07:20:33 -06:00
iterate_method_candidates(
ty,
db,
env,
krate,
2021-06-12 22:54:16 -05:00
traits_in_scope,
visible_from_module,
2020-01-14 07:20:33 -06:00
Some(name),
LookupMode::MethodCall,
|ty, f| match f {
AssocItemId::FunctionId(f) => Some((ty.clone(), f)),
_ => None,
},
)
}
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`).
#[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.
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.
Path,
}
2019-03-24 11:36:15 -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?
2019-11-27 08:46:02 -06:00
pub fn iterate_method_candidates<T>(
ty: &Canonical<Ty>,
db: &dyn HirDatabase,
2020-01-14 07:20:33 -06:00
env: Arc<TraitEnvironment>,
krate: CrateId,
traits_in_scope: &FxHashSet<TraitId>,
visible_from_module: Option<ModuleId>,
name: Option<&Name>,
mode: LookupMode,
2019-11-27 03:31:40 -06:00
mut callback: impl FnMut(&Ty, AssocItemId) -> Option<T>,
) -> Option<T> {
let mut slot = None;
iterate_method_candidates_impl(
ty,
db,
env,
krate,
traits_in_scope,
visible_from_module,
name,
mode,
&mut |ty, item| {
2020-06-26 05:04:11 -05:00
assert!(slot.is_none());
slot = callback(ty, item);
slot.is_some()
},
);
slot
}
2020-06-26 05:04:11 -05:00
fn iterate_method_candidates_impl(
ty: &Canonical<Ty>,
db: &dyn HirDatabase,
env: Arc<TraitEnvironment>,
krate: CrateId,
traits_in_scope: &FxHashSet<TraitId>,
visible_from_module: Option<ModuleId>,
name: Option<&Name>,
mode: LookupMode,
callback: &mut dyn FnMut(&Ty, AssocItemId) -> bool,
) -> bool {
2019-10-31 14:01:46 -05:00
match mode {
LookupMode::MethodCall => {
// For method calls, rust first does any number of autoderef, and then one
// autoref (i.e. when the method takes &self or &mut self). We just ignore
// the autoref currently -- when we find a method matching the given name,
// we assume it fits.
2019-10-31 14:01:46 -05:00
// Also 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).
let ty = InEnvironment { goal: ty.clone(), environment: env.env.clone() };
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.
//
// 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*.
let deref_chain = autoderef_method_receiver(db, krate, ty);
for i in 0..deref_chain.len() {
if iterate_method_candidates_with_autoref(
&deref_chain[i..],
2019-10-31 14:01:46 -05:00
db,
2020-01-14 07:11:07 -06:00
env.clone(),
krate,
2020-01-14 07:20:33 -06:00
traits_in_scope,
visible_from_module,
2019-10-31 14:01:46 -05:00
name,
callback,
2019-10-31 14:01:46 -05:00
) {
return true;
2019-10-31 14:01:46 -05:00
}
}
false
}
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,
env,
krate,
2020-01-14 07:20:33 -06:00
traits_in_scope,
visible_from_module,
2020-01-14 07:11:07 -06:00
name,
callback,
2020-01-14 07:11:07 -06:00
)
}
}
}
fn iterate_method_candidates_with_autoref(
deref_chain: &[Canonical<Ty>],
db: &dyn HirDatabase,
2020-01-14 07:11:07 -06:00
env: Arc<TraitEnvironment>,
krate: CrateId,
traits_in_scope: &FxHashSet<TraitId>,
visible_from_module: Option<ModuleId>,
name: Option<&Name>,
mut callback: &mut dyn FnMut(&Ty, AssocItemId) -> bool,
) -> bool {
if iterate_method_candidates_by_receiver(
2019-12-01 15:14:28 -06:00
&deref_chain[0],
&deref_chain[1..],
db,
2020-01-14 07:11:07 -06:00
env.clone(),
krate,
2021-06-12 22:54:16 -05:00
traits_in_scope,
visible_from_module,
2019-12-01 15:14:28 -06:00
name,
&mut callback,
) {
return true;
}
let refed = Canonical {
binders: deref_chain[0].binders.clone(),
value: TyKind::Ref(Mutability::Not, static_lifetime(), deref_chain[0].value.clone())
.intern(&Interner),
};
if iterate_method_candidates_by_receiver(
2019-12-01 15:14:28 -06:00
&refed,
deref_chain,
db,
2020-01-14 07:11:07 -06:00
env.clone(),
krate,
2021-06-12 22:54:16 -05:00
traits_in_scope,
visible_from_module,
2019-12-01 15:14:28 -06:00
name,
&mut callback,
) {
return true;
}
let ref_muted = Canonical {
binders: deref_chain[0].binders.clone(),
value: TyKind::Ref(Mutability::Mut, static_lifetime(), deref_chain[0].value.clone())
.intern(&Interner),
};
if iterate_method_candidates_by_receiver(
2019-12-01 15:14:28 -06:00
&ref_muted,
deref_chain,
db,
env,
2020-01-14 07:11:07 -06:00
krate,
2021-06-12 22:54:16 -05:00
traits_in_scope,
visible_from_module,
2019-12-01 15:14:28 -06:00
name,
&mut callback,
) {
return true;
}
false
}
fn iterate_method_candidates_by_receiver(
receiver_ty: &Canonical<Ty>,
2019-12-02 11:12:49 -06:00
rest_of_deref_chain: &[Canonical<Ty>],
db: &dyn HirDatabase,
2020-01-14 07:11:07 -06:00
env: Arc<TraitEnvironment>,
krate: CrateId,
traits_in_scope: &FxHashSet<TraitId>,
visible_from_module: Option<ModuleId>,
name: Option<&Name>,
mut callback: &mut dyn FnMut(&Ty, AssocItemId) -> bool,
) -> bool {
// 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.
2019-12-02 11:12:49 -06:00
for self_ty in std::iter::once(receiver_ty).chain(rest_of_deref_chain) {
if iterate_inherent_methods(
self_ty,
db,
env.clone(),
name,
Some(receiver_ty),
krate,
visible_from_module,
&mut callback,
) {
return true;
2019-12-02 11:12:49 -06:00
}
}
for self_ty in std::iter::once(receiver_ty).chain(rest_of_deref_chain) {
if iterate_trait_method_candidates(
2019-12-01 15:14:28 -06:00
self_ty,
db,
2020-01-14 07:11:07 -06:00
env.clone(),
krate,
2021-06-12 22:54:16 -05:00
traits_in_scope,
2019-12-01 15:14:28 -06:00
name,
Some(receiver_ty),
&mut callback,
) {
return true;
}
}
false
}
fn iterate_method_candidates_for_self_ty(
self_ty: &Canonical<Ty>,
db: &dyn HirDatabase,
2020-01-14 07:11:07 -06:00
env: Arc<TraitEnvironment>,
krate: CrateId,
traits_in_scope: &FxHashSet<TraitId>,
visible_from_module: Option<ModuleId>,
name: Option<&Name>,
mut callback: &mut dyn FnMut(&Ty, AssocItemId) -> bool,
) -> bool {
if iterate_inherent_methods(
self_ty,
db,
env.clone(),
name,
None,
krate,
visible_from_module,
&mut callback,
) {
return true;
}
iterate_trait_method_candidates(self_ty, db, env, krate, traits_in_scope, name, None, callback)
}
fn iterate_trait_method_candidates(
self_ty: &Canonical<Ty>,
db: &dyn HirDatabase,
2020-01-14 07:11:07 -06:00
env: Arc<TraitEnvironment>,
krate: CrateId,
traits_in_scope: &FxHashSet<TraitId>,
name: Option<&Name>,
receiver_ty: Option<&Canonical<Ty>>,
callback: &mut dyn FnMut(&Ty, AssocItemId) -> bool,
) -> bool {
let receiver_is_array = matches!(self_ty.value.kind(&Interner), chalk_ir::TyKind::Array(..));
// if ty is `dyn Trait`, the trait doesn't need to be in scope
let inherent_trait =
self_ty.value.dyn_trait().into_iter().flat_map(|t| all_super_traits(db.upcast(), t));
let env_traits = if let TyKind::Placeholder(_) = self_ty.value.kind(&Interner) {
// if we have `T: Trait` in the param env, the trait doesn't need to be in scope
2021-03-12 12:12:17 -06:00
env.traits_in_scope_from_clauses(&self_ty.value)
.flat_map(|t| all_super_traits(db.upcast(), t))
.collect()
} else {
Vec::new()
};
let traits =
inherent_trait.chain(env_traits.into_iter()).chain(traits_in_scope.iter().copied());
'traits: for t in traits {
2019-11-26 09:00:36 -06:00
let data = db.trait_data(t);
// 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.
if data.skip_array_during_method_dispatch && receiver_is_array {
// FIXME: this should really be using the edition of the method name's span, in case it
// comes from a macro
if db.crate_graph()[krate].edition < Edition::Edition2021 {
continue;
}
}
// 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;
2019-11-26 08:12:16 -06:00
for (_name, item) in data.items.iter() {
// Don't pass a `visible_from_module` down to `is_valid_candidate`,
// since only inherent methods should be included into visibility checking.
if !is_valid_candidate(db, env.clone(), name, receiver_ty, *item, self_ty, None) {
2019-10-31 14:37:46 -05:00
continue;
}
if !known_implemented {
let goal = generic_implements_goal(db, env.clone(), t, self_ty.clone());
if db.trait_solve(krate, goal.cast(&Interner)).is_none() {
continue 'traits;
}
}
known_implemented = true;
// FIXME: we shouldn't be ignoring the binders here
if callback(&self_ty.value, *item) {
return true;
2019-03-24 11:36:15 -05:00
}
}
}
false
}
fn iterate_inherent_methods(
self_ty: &Canonical<Ty>,
db: &dyn HirDatabase,
env: Arc<TraitEnvironment>,
name: Option<&Name>,
receiver_ty: Option<&Canonical<Ty>>,
2019-11-26 13:26:47 -06:00
krate: CrateId,
visible_from_module: Option<ModuleId>,
callback: &mut dyn FnMut(&Ty, AssocItemId) -> bool,
) -> bool {
2021-04-07 06:09:31 -05:00
let def_crates = match def_crates(db, &self_ty.value, krate) {
Some(k) => k,
None => return false,
};
for krate in def_crates {
let impls = db.inherent_impls_in_crate(krate);
for &impl_def in impls.for_self_ty(&self_ty.value) {
2020-02-29 14:24:40 -06:00
for &item in db.impl_data(impl_def).items.iter() {
if !is_valid_candidate(
db,
env.clone(),
name,
receiver_ty,
item,
self_ty,
visible_from_module,
) {
2019-10-31 14:37:46 -05:00
continue;
}
// we have to check whether the self type unifies with the type
// that the impl is for. If we have a receiver type, this
// already happens in `is_valid_candidate` above; if not, we
// check it here
if receiver_ty.is_none()
&& inherent_impl_substs(db, env.clone(), impl_def, self_ty).is_none()
{
2021-03-08 14:19:44 -06:00
cov_mark::hit!(impl_self_type_match_without_receiver);
continue;
}
let receiver_ty = receiver_ty.map(|x| &x.value).unwrap_or(&self_ty.value);
if callback(receiver_ty, item) {
return true;
}
}
}
}
false
}
2020-02-29 15:48:23 -06:00
/// Returns the self type for the index trait call.
pub fn resolve_indexing_op(
db: &dyn HirDatabase,
2020-02-29 15:48:23 -06:00
ty: &Canonical<Ty>,
env: Arc<TraitEnvironment>,
krate: CrateId,
index_trait: TraitId,
) -> Option<Canonical<Ty>> {
let ty = InEnvironment { goal: ty.clone(), environment: env.env.clone() };
2020-02-29 15:48:23 -06:00
let deref_chain = autoderef_method_receiver(db, krate, ty);
for ty in deref_chain {
let goal = generic_implements_goal(db, env.clone(), index_trait, ty.clone());
if db.trait_solve(krate, goal.cast(&Interner)).is_some() {
2020-02-29 15:48:23 -06:00
return Some(ty);
}
}
None
}
2019-10-31 14:37:46 -05:00
fn is_valid_candidate(
db: &dyn HirDatabase,
env: Arc<TraitEnvironment>,
2019-10-31 14:37:46 -05:00
name: Option<&Name>,
receiver_ty: Option<&Canonical<Ty>>,
2019-11-26 06:27:33 -06:00
item: AssocItemId,
self_ty: &Canonical<Ty>,
visible_from_module: Option<ModuleId>,
2019-10-31 14:37:46 -05:00
) -> bool {
match item {
2019-11-26 06:27:33 -06:00
AssocItemId::FunctionId(m) => {
let data = db.function_data(m);
if let Some(name) = name {
if &data.name != name {
return false;
}
}
if let Some(receiver_ty) = receiver_ty {
if !data.has_self_param() {
return false;
}
let transformed_receiver_ty = match transform_receiver_ty(db, env, m, self_ty) {
2019-12-02 11:12:49 -06:00
Some(ty) => ty,
None => return false,
2019-12-01 15:14:28 -06:00
};
2019-12-02 11:12:49 -06:00
if transformed_receiver_ty != receiver_ty.value {
2019-12-01 15:14:28 -06:00
return false;
}
}
if let Some(from_module) = visible_from_module {
if !db.function_visibility(m).is_visible_from(db.upcast(), from_module) {
cov_mark::hit!(autoderef_candidate_not_visible);
return false;
}
}
true
2019-10-31 14:37:46 -05:00
}
2019-11-26 06:27:33 -06:00
AssocItemId::ConstId(c) => {
let data = db.const_data(c);
name.map_or(true, |name| data.name.as_ref() == Some(name)) && receiver_ty.is_none()
2019-10-31 14:37:46 -05:00
}
_ => false,
}
}
2019-12-02 11:12:49 -06:00
pub(crate) fn inherent_impl_substs(
db: &dyn HirDatabase,
env: Arc<TraitEnvironment>,
2019-12-02 11:12:49 -06:00
impl_id: ImplId,
self_ty: &Canonical<Ty>,
2021-03-15 15:02:34 -05:00
) -> Option<Substitution> {
// we create a var for each type parameter of the impl; we need to keep in
// mind here that `self_ty` might have vars of its own
2021-04-05 14:49:27 -05:00
let self_ty_vars = self_ty.binders.len(&Interner);
let vars = TyBuilder::subst_for_def(db, impl_id)
2021-04-05 14:49:27 -05:00
.fill_with_bound_vars(DebruijnIndex::INNERMOST, self_ty_vars)
.build();
let self_ty_with_vars = db.impl_self_ty(impl_id).substitute(&Interner, &vars);
let mut kinds = self_ty.binders.interned().to_vec();
kinds.extend(
iter::repeat(chalk_ir::WithKind::new(
chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General),
UniverseIndex::ROOT,
))
.take(vars.len(&Interner)),
);
let tys = Canonical {
binders: CanonicalVarKinds::from_iter(&Interner, kinds),
value: (self_ty_with_vars, self_ty.value.clone()),
};
let substs = super::infer::unify(db, env, &tys)?;
// We only want the substs for the vars we added, not the ones from self_ty.
// Also, if any of the vars we added are still in there, we replace them by
// Unknown. I think this can only really happen if self_ty contained
// Unknown, and in that case we want the result to contain Unknown in those
// places again.
2021-04-05 14:49:27 -05:00
let suffix =
Substitution::from_iter(&Interner, substs.iter(&Interner).cloned().skip(self_ty_vars));
Some(fallback_bound_vars(suffix, self_ty_vars))
}
/// This replaces any 'free' Bound vars in `s` (i.e. those with indices past
/// num_vars_to_keep) by `TyKind::Unknown`.
2021-03-15 15:02:34 -05:00
fn fallback_bound_vars(s: Substitution, num_vars_to_keep: usize) -> Substitution {
2021-04-07 14:26:37 -05:00
crate::fold_free_vars(s, |bound, binders| {
if bound.index >= num_vars_to_keep && bound.debruijn == DebruijnIndex::INNERMOST {
TyKind::Error.intern(&Interner)
} else {
bound.shifted_in_from(binders).to_ty(&Interner)
}
})
2019-12-02 11:12:49 -06:00
}
fn transform_receiver_ty(
db: &dyn HirDatabase,
env: Arc<TraitEnvironment>,
2019-12-02 11:12:49 -06:00
function_id: FunctionId,
self_ty: &Canonical<Ty>,
) -> Option<Ty> {
let substs = match function_id.lookup(db.upcast()).container {
AssocContainerId::TraitId(_) => TyBuilder::subst_for_def(db, function_id)
2019-12-02 11:12:49 -06:00
.push(self_ty.value.clone())
.fill_with_unknown()
.build(),
AssocContainerId::ImplId(impl_id) => {
2021-06-12 22:54:16 -05:00
let impl_substs = inherent_impl_substs(db, env, impl_id, self_ty)?;
TyBuilder::subst_for_def(db, function_id)
.use_parent_substs(&impl_substs)
.fill_with_unknown()
.build()
}
AssocContainerId::ModuleId(_) => unreachable!(),
2019-12-02 11:12:49 -06:00
};
let sig = db.callable_item_signature(function_id.into());
Some(sig.map(|s| s.params()[0].clone()).substitute(&Interner, &substs))
2019-12-02 11:12:49 -06:00
}
2019-11-27 08:46:02 -06:00
pub fn implements_trait(
2019-08-02 13:16:20 -05:00
ty: &Canonical<Ty>,
db: &dyn HirDatabase,
env: Arc<TraitEnvironment>,
2019-11-26 13:26:47 -06:00
krate: CrateId,
2019-11-26 09:00:36 -06:00
trait_: TraitId,
2019-08-02 13:16:20 -05:00
) -> bool {
2019-09-24 20:32:01 -05:00
let goal = generic_implements_goal(db, env, trait_, ty.clone());
let solution = db.trait_solve(krate, goal.cast(&Interner));
solution.is_some()
}
pub fn implements_trait_unique(
ty: &Canonical<Ty>,
db: &dyn HirDatabase,
env: Arc<TraitEnvironment>,
krate: CrateId,
trait_: TraitId,
) -> bool {
let goal = generic_implements_goal(db, env, trait_, ty.clone());
let solution = db.trait_solve(krate, goal.cast(&Interner));
matches!(solution, Some(crate::Solution::Unique(_)))
}
2019-04-09 15:04:59 -05:00
/// This creates Substs for a trait with the given Self type and type variables
/// for all other parameters, to query Chalk with it.
fn generic_implements_goal(
db: &dyn HirDatabase,
2019-07-09 14:34:23 -05:00
env: Arc<TraitEnvironment>,
2019-11-26 09:00:36 -06:00
trait_: TraitId,
self_ty: Canonical<Ty>,
) -> Canonical<InEnvironment<super::DomainGoal>> {
let mut kinds = self_ty.binders.interned().to_vec();
let trait_ref = TyBuilder::trait_ref(db, trait_)
.push(self_ty.value)
.fill_with_bound_vars(DebruijnIndex::INNERMOST, kinds.len())
.build();
kinds.extend(
iter::repeat(chalk_ir::WithKind::new(
chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General),
UniverseIndex::ROOT,
))
.take(trait_ref.substitution.len(&Interner) - 1),
);
let obligation = trait_ref.cast(&Interner);
Canonical {
binders: CanonicalVarKinds::from_iter(&Interner, kinds),
2021-04-07 13:48:58 -05:00
value: InEnvironment::new(&env.env, obligation),
}
}
fn autoderef_method_receiver(
db: &dyn HirDatabase,
krate: CrateId,
ty: InEnvironment<Canonical<Ty>>,
) -> Vec<Canonical<Ty>> {
let mut deref_chain: Vec<_> = autoderef::autoderef(db, Some(krate), ty).collect();
// As a last step, we can do array unsizing (that's the only unsizing that rustc does for method receivers!)
2021-04-06 04:45:41 -05:00
if let Some(TyKind::Array(parameters, _)) =
deref_chain.last().map(|ty| ty.value.kind(&Interner))
{
let kinds = deref_chain.last().unwrap().binders.clone();
let unsized_ty = TyKind::Slice(parameters.clone()).intern(&Interner);
deref_chain.push(Canonical { value: unsized_ty, binders: kinds })
}
deref_chain
}