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)
|
|
|
|
//! and the corresponding code mostly in librustc_typeck/check/method/probe.rs.
|
2020-06-28 14:17:27 -05:00
|
|
|
use std::{iter, sync::Arc};
|
2019-01-07 06:44:54 -06:00
|
|
|
|
2019-06-24 12:17:44 -05:00
|
|
|
use arrayvec::ArrayVec;
|
2021-06-01 14:33:14 -05:00
|
|
|
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::{
|
2021-04-06 20:33:22 -05:00
|
|
|
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};
|
2019-01-07 06:44:54 -06:00
|
|
|
|
2019-01-12 14:27:35 -06:00
|
|
|
use crate::{
|
2020-07-11 12:12:10 -05:00
|
|
|
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},
|
2021-04-06 03:50:55 -05:00
|
|
|
static_lifetime,
|
2020-07-11 12:12:10 -05:00
|
|
|
utils::all_super_traits,
|
2021-04-11 04:42:54 -05:00
|
|
|
AdtId, Canonical, CanonicalVarKinds, DebruijnIndex, ForeignDefId, InEnvironment, Interner,
|
|
|
|
Scalar, Substitution, TraitEnvironment, TraitRefExt, Ty, TyBuilder, TyExt, TyKind,
|
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-04-05 15:23:16 -05: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> {
|
|
|
|
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)?,
|
2021-04-07 12:35:24 -05:00
|
|
|
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)
|
|
|
|
}
|
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> {
|
2020-08-12 09:32:36 -05:00
|
|
|
let _p = profile::span("trait_impls_in_crate_query");
|
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-04-06 20:33:22 -05:00
|
|
|
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);
|
2021-04-07 12:35:24 -05:00
|
|
|
let self_ty_fp = TyFingerprint::for_trait_impl(self_ty.skip_binders());
|
2021-04-06 20:33:22 -05:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
2020-07-01 10:15:20 -05:00
|
|
|
}
|
|
|
|
}
|
2020-06-18 18:29:34 -05:00
|
|
|
}
|
|
|
|
|
2020-07-01 10:15:20 -05:00
|
|
|
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");
|
2020-06-18 18:29:34 -05:00
|
|
|
let crate_graph = db.crate_graph();
|
2020-07-01 10:15:20 -05:00
|
|
|
let mut res = Self { map: FxHashMap::default() };
|
2020-06-18 18:29:34 -05:00
|
|
|
|
2020-07-01 08:19:36 -05:00
|
|
|
for krate in crate_graph.transitive_deps(krate) {
|
2020-07-01 10:15:20 -05:00
|
|
|
res.merge(&db.trait_impls_in_crate(krate));
|
2020-06-18 18:29:34 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
Arc::new(res)
|
|
|
|
}
|
|
|
|
|
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 {
|
|
|
|
let vec = map.entry(*fp).or_default();
|
|
|
|
vec.extend(impls);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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()
|
2020-07-01 10:15:20 -05:00
|
|
|
.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> {
|
2021-04-18 18:06:26 -05:00
|
|
|
let mut impls = Self { map: FxHashMap::default() };
|
2020-07-01 10:15:20 -05:00
|
|
|
|
|
|
|
let crate_def_map = db.crate_def_map(krate);
|
2021-04-18 18:06:26 -05:00
|
|
|
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)
|
2020-07-01 10:15:20 -05:00
|
|
|
}
|
|
|
|
|
2021-04-18 18:06:26 -05:00
|
|
|
// 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);
|
|
|
|
}
|
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
|
|
|
}
|
2019-01-07 06:44:54 -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-02-08 12:13:54 -06:00
|
|
|
|
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)
|
2019-01-07 06:44:54 -06:00
|
|
|
}
|
2021-02-08 12:13:54 -06:00
|
|
|
|
2019-05-01 10:57:56 -05:00
|
|
|
/// 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>,
|
2020-03-13 10:05:46 -05:00
|
|
|
db: &dyn HirDatabase,
|
2020-01-14 07:20:33 -06:00
|
|
|
env: Arc<TraitEnvironment>,
|
|
|
|
krate: CrateId,
|
|
|
|
traits_in_scope: &FxHashSet<TraitId>,
|
2021-03-20 13:28:26 -05:00
|
|
|
visible_from_module: Option<ModuleId>,
|
2019-05-01 10:57:56 -05:00
|
|
|
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,
|
2021-03-20 13:28:26 -05:00
|
|
|
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-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
|
|
|
|
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?
|
2019-11-27 08:46:02 -06:00
|
|
|
pub 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>,
|
|
|
|
krate: CrateId,
|
|
|
|
traits_in_scope: &FxHashSet<TraitId>,
|
2021-03-20 13:28:26 -05:00
|
|
|
visible_from_module: Option<ModuleId>,
|
2019-05-01 10:57:56 -05:00
|
|
|
name: Option<&Name>,
|
2019-10-31 13:28:33 -05:00
|
|
|
mode: LookupMode,
|
2019-11-27 03:31:40 -06:00
|
|
|
mut callback: impl FnMut(&Ty, AssocItemId) -> Option<T>,
|
2019-05-01 10:57:56 -05:00
|
|
|
) -> Option<T> {
|
2020-06-24 10:45:38 -05:00
|
|
|
let mut slot = None;
|
|
|
|
iterate_method_candidates_impl(
|
|
|
|
ty,
|
|
|
|
db,
|
|
|
|
env,
|
|
|
|
krate,
|
|
|
|
traits_in_scope,
|
2021-03-20 13:28:26 -05:00
|
|
|
visible_from_module,
|
2020-06-24 10:45:38 -05:00
|
|
|
name,
|
|
|
|
mode,
|
|
|
|
&mut |ty, item| {
|
2020-06-26 05:04:11 -05:00
|
|
|
assert!(slot.is_none());
|
2020-06-24 10:45:38 -05:00
|
|
|
slot = callback(ty, item);
|
|
|
|
slot.is_some()
|
|
|
|
},
|
|
|
|
);
|
|
|
|
slot
|
|
|
|
}
|
|
|
|
|
2020-06-26 05:04:11 -05:00
|
|
|
fn iterate_method_candidates_impl(
|
2020-06-24 10:45:38 -05:00
|
|
|
ty: &Canonical<Ty>,
|
|
|
|
db: &dyn HirDatabase,
|
|
|
|
env: Arc<TraitEnvironment>,
|
|
|
|
krate: CrateId,
|
|
|
|
traits_in_scope: &FxHashSet<TraitId>,
|
2021-03-20 13:28:26 -05:00
|
|
|
visible_from_module: Option<ModuleId>,
|
2020-06-24 10:45:38 -05:00
|
|
|
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-04-14 09:08:10 -05:00
|
|
|
|
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).
|
2021-03-21 14:19:07 -05:00
|
|
|
let ty = InEnvironment { goal: ty.clone(), environment: env.env.clone() };
|
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*.
|
|
|
|
|
2020-02-29 15:01:36 -06:00
|
|
|
let deref_chain = autoderef_method_receiver(db, krate, ty);
|
2019-11-02 09:18:26 -05:00
|
|
|
for i in 0..deref_chain.len() {
|
2020-06-24 10:45:38 -05:00
|
|
|
if iterate_method_candidates_with_autoref(
|
2019-11-02 09:18:26 -05:00
|
|
|
&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,
|
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,
|
2019-10-31 14:01:46 -05:00
|
|
|
) {
|
2020-06-24 10:45:38 -05:00
|
|
|
return true;
|
2019-10-31 14:01:46 -05:00
|
|
|
}
|
|
|
|
}
|
2020-06-24 10:45:38 -05:00
|
|
|
false
|
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,
|
|
|
|
env,
|
|
|
|
krate,
|
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(
|
2019-11-02 09:18:26 -05:00
|
|
|
deref_chain: &[Canonical<Ty>],
|
2020-03-13 10:05:46 -05:00
|
|
|
db: &dyn HirDatabase,
|
2020-01-14 07:11:07 -06:00
|
|
|
env: Arc<TraitEnvironment>,
|
|
|
|
krate: CrateId,
|
|
|
|
traits_in_scope: &FxHashSet<TraitId>,
|
2021-03-20 13:28:26 -05:00
|
|
|
visible_from_module: Option<ModuleId>,
|
2019-11-02 09:18:26 -05:00
|
|
|
name: Option<&Name>,
|
2020-06-24 10:45:38 -05:00
|
|
|
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,
|
2021-03-20 13:28:26 -05:00
|
|
|
visible_from_module,
|
2019-12-01 15:14:28 -06:00
|
|
|
name,
|
|
|
|
&mut callback,
|
|
|
|
) {
|
2020-06-24 10:45:38 -05:00
|
|
|
return true;
|
2019-11-02 09:18:26 -05:00
|
|
|
}
|
|
|
|
let refed = Canonical {
|
2021-03-21 14:05:38 -05:00
|
|
|
binders: deref_chain[0].binders.clone(),
|
2021-04-06 03:50:55 -05:00
|
|
|
value: TyKind::Ref(Mutability::Not, static_lifetime(), deref_chain[0].value.clone())
|
|
|
|
.intern(&Interner),
|
2019-11-02 09:18:26 -05:00
|
|
|
};
|
2020-06-24 10:45:38 -05:00
|
|
|
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,
|
2021-03-20 13:28:26 -05:00
|
|
|
visible_from_module,
|
2019-12-01 15:14:28 -06:00
|
|
|
name,
|
|
|
|
&mut callback,
|
|
|
|
) {
|
2020-06-24 10:45:38 -05:00
|
|
|
return true;
|
2019-11-02 09:18:26 -05:00
|
|
|
}
|
|
|
|
let ref_muted = Canonical {
|
2021-03-21 14:05:38 -05:00
|
|
|
binders: deref_chain[0].binders.clone(),
|
2021-04-06 03:50:55 -05:00
|
|
|
value: TyKind::Ref(Mutability::Mut, static_lifetime(), deref_chain[0].value.clone())
|
|
|
|
.intern(&Interner),
|
2019-11-02 09:18:26 -05:00
|
|
|
};
|
2020-06-24 10:45:38 -05:00
|
|
|
if iterate_method_candidates_by_receiver(
|
2019-12-01 15:14:28 -06:00
|
|
|
&ref_muted,
|
|
|
|
deref_chain,
|
|
|
|
db,
|
2020-02-18 06:53:02 -06:00
|
|
|
env,
|
2020-01-14 07:11:07 -06:00
|
|
|
krate,
|
2021-06-12 22:54:16 -05:00
|
|
|
traits_in_scope,
|
2021-03-20 13:28:26 -05:00
|
|
|
visible_from_module,
|
2019-12-01 15:14:28 -06:00
|
|
|
name,
|
|
|
|
&mut callback,
|
|
|
|
) {
|
2020-06-24 10:45:38 -05:00
|
|
|
return true;
|
2019-11-02 09:18:26 -05:00
|
|
|
}
|
2020-06-24 10:45:38 -05:00
|
|
|
false
|
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>,
|
2019-12-02 11:12:49 -06:00
|
|
|
rest_of_deref_chain: &[Canonical<Ty>],
|
2020-03-13 10:05:46 -05:00
|
|
|
db: &dyn HirDatabase,
|
2020-01-14 07:11:07 -06:00
|
|
|
env: Arc<TraitEnvironment>,
|
|
|
|
krate: CrateId,
|
|
|
|
traits_in_scope: &FxHashSet<TraitId>,
|
2021-03-20 13:28:26 -05:00
|
|
|
visible_from_module: Option<ModuleId>,
|
2019-11-02 09:18:26 -05:00
|
|
|
name: Option<&Name>,
|
2020-06-24 10:45:38 -05:00
|
|
|
mut callback: &mut dyn FnMut(&Ty, AssocItemId) -> bool,
|
|
|
|
) -> bool {
|
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.
|
2019-12-02 11:12:49 -06:00
|
|
|
for self_ty in std::iter::once(receiver_ty).chain(rest_of_deref_chain) {
|
2021-03-20 13:28:26 -05:00
|
|
|
if iterate_inherent_methods(
|
|
|
|
self_ty,
|
|
|
|
db,
|
2021-05-16 08:50:28 -05:00
|
|
|
env.clone(),
|
2021-03-20 13:28:26 -05:00
|
|
|
name,
|
|
|
|
Some(receiver_ty),
|
|
|
|
krate,
|
|
|
|
visible_from_module,
|
|
|
|
&mut callback,
|
|
|
|
) {
|
2020-06-24 10:45:38 -05:00
|
|
|
return true;
|
2019-12-02 11:12:49 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
for self_ty in std::iter::once(receiver_ty).chain(rest_of_deref_chain) {
|
2020-06-24 10:45:38 -05:00
|
|
|
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,
|
|
|
|
) {
|
2020-06-24 10:45:38 -05:00
|
|
|
return true;
|
2019-04-14 09:08:10 -05:00
|
|
|
}
|
|
|
|
}
|
2020-06-24 10:45:38 -05:00
|
|
|
false
|
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>,
|
|
|
|
krate: CrateId,
|
|
|
|
traits_in_scope: &FxHashSet<TraitId>,
|
2021-03-20 13:48:35 -05:00
|
|
|
visible_from_module: Option<ModuleId>,
|
2019-11-02 09:18:26 -05:00
|
|
|
name: Option<&Name>,
|
2020-06-24 10:45:38 -05:00
|
|
|
mut callback: &mut dyn FnMut(&Ty, AssocItemId) -> bool,
|
|
|
|
) -> bool {
|
2021-05-16 08:50:28 -05:00
|
|
|
if iterate_inherent_methods(
|
|
|
|
self_ty,
|
|
|
|
db,
|
|
|
|
env.clone(),
|
|
|
|
name,
|
|
|
|
None,
|
|
|
|
krate,
|
|
|
|
visible_from_module,
|
|
|
|
&mut callback,
|
|
|
|
) {
|
2020-06-24 10:45:38 -05:00
|
|
|
return true;
|
2019-11-02 09:18:26 -05:00
|
|
|
}
|
2020-06-24 10:45:38 -05:00
|
|
|
iterate_trait_method_candidates(self_ty, db, env, krate, traits_in_scope, name, None, callback)
|
2019-11-02 09:18:26 -05:00
|
|
|
}
|
|
|
|
|
2020-06-24 10:45:38 -05:00
|
|
|
fn iterate_trait_method_candidates(
|
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>,
|
|
|
|
krate: CrateId,
|
|
|
|
traits_in_scope: &FxHashSet<TraitId>,
|
2019-05-01 10:57:56 -05:00
|
|
|
name: Option<&Name>,
|
2019-11-02 09:18:26 -05:00
|
|
|
receiver_ty: Option<&Canonical<Ty>>,
|
2020-06-24 10:45:38 -05:00
|
|
|
callback: &mut dyn FnMut(&Ty, AssocItemId) -> bool,
|
|
|
|
) -> bool {
|
2021-06-01 14:33:14 -05:00
|
|
|
let receiver_is_array = matches!(self_ty.value.kind(&Interner), chalk_ir::TyKind::Array(..));
|
2020-05-16 11:32:15 -05:00
|
|
|
// 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));
|
2021-04-03 06:08:29 -05:00
|
|
|
let env_traits = if let TyKind::Placeholder(_) = self_ty.value.kind(&Interner) {
|
2020-02-18 05:26:00 -06:00
|
|
|
// 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)
|
2020-03-13 10:05:46 -05:00
|
|
|
.flat_map(|t| all_super_traits(db.upcast(), t))
|
2020-02-18 05:26:00 -06:00
|
|
|
.collect()
|
|
|
|
} else {
|
|
|
|
Vec::new()
|
|
|
|
};
|
|
|
|
let traits =
|
|
|
|
inherent_trait.chain(env_traits.into_iter()).chain(traits_in_scope.iter().copied());
|
2019-08-22 06:23:50 -05:00
|
|
|
'traits: for t in traits {
|
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.
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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;
|
2019-11-26 08:12:16 -06:00
|
|
|
for (_name, 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.
|
2021-05-16 08:50:28 -05:00
|
|
|
if !is_valid_candidate(db, env.clone(), name, receiver_ty, *item, self_ty, None) {
|
2019-10-31 14:37:46 -05:00
|
|
|
continue;
|
|
|
|
}
|
2019-10-31 13:28:33 -05:00
|
|
|
if !known_implemented {
|
2019-11-02 09:18:26 -05:00
|
|
|
let goal = generic_implements_goal(db, env.clone(), t, self_ty.clone());
|
2021-05-16 08:50:28 -05:00
|
|
|
if db.trait_solve(krate, goal.cast(&Interner)).is_none() {
|
2019-10-31 13:28:33 -05:00
|
|
|
continue 'traits;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
known_implemented = true;
|
2021-04-08 16:34:05 -05:00
|
|
|
// FIXME: we shouldn't be ignoring the binders here
|
2020-06-24 10:45:38 -05:00
|
|
|
if callback(&self_ty.value, *item) {
|
|
|
|
return true;
|
2019-03-24 11:36:15 -05:00
|
|
|
}
|
|
|
|
}
|
2019-01-07 06:44:54 -06:00
|
|
|
}
|
2020-06-24 10:45:38 -05:00
|
|
|
false
|
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(
|
2019-11-02 09:18:26 -05:00
|
|
|
self_ty: &Canonical<Ty>,
|
2020-03-13 10:05:46 -05:00
|
|
|
db: &dyn HirDatabase,
|
2021-05-16 08:50:28 -05:00
|
|
|
env: Arc<TraitEnvironment>,
|
2019-05-01 10:57:56 -05:00
|
|
|
name: Option<&Name>,
|
2019-11-02 09:18:26 -05:00
|
|
|
receiver_ty: Option<&Canonical<Ty>>,
|
2019-11-26 13:26:47 -06:00
|
|
|
krate: CrateId,
|
2021-03-20 13:28:26 -05:00
|
|
|
visible_from_module: Option<ModuleId>,
|
2020-06-24 10:45:38 -05:00
|
|
|
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) {
|
2020-06-24 10:45:38 -05:00
|
|
|
Some(k) => k,
|
|
|
|
None => return false,
|
|
|
|
};
|
|
|
|
for krate in def_crates {
|
2020-07-01 10:15:20 -05:00
|
|
|
let impls = db.inherent_impls_in_crate(krate);
|
2019-01-07 06:44:54 -06:00
|
|
|
|
2020-07-01 10:15:20 -05:00
|
|
|
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() {
|
2021-05-16 08:50:28 -05:00
|
|
|
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;
|
2019-10-31 13:28:33 -05:00
|
|
|
}
|
2020-02-14 14:08:25 -06:00
|
|
|
// 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
|
2021-05-16 08:50:28 -05:00
|
|
|
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);
|
2020-02-14 14:08:25 -06:00
|
|
|
continue;
|
|
|
|
}
|
2021-05-31 13:04:18 -05:00
|
|
|
let receiver_ty = receiver_ty.map(|x| &x.value).unwrap_or(&self_ty.value);
|
|
|
|
if callback(receiver_ty, item) {
|
2020-06-24 10:45:38 -05:00
|
|
|
return true;
|
2019-01-07 06:44:54 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-06-24 10:45:38 -05:00
|
|
|
false
|
2019-05-01 10:57:56 -05:00
|
|
|
}
|
2019-02-12 02:33:23 -06:00
|
|
|
|
2020-02-29 15:48:23 -06:00
|
|
|
/// Returns the self type for the index trait call.
|
|
|
|
pub fn resolve_indexing_op(
|
2020-03-13 10:05:46 -05:00
|
|
|
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>> {
|
2021-03-21 14:19:07 -05:00
|
|
|
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());
|
2021-05-16 08:50:28 -05:00
|
|
|
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(
|
2020-03-13 10:05:46 -05:00
|
|
|
db: &dyn HirDatabase,
|
2021-05-16 08:50:28 -05:00
|
|
|
env: Arc<TraitEnvironment>,
|
2019-10-31 14:37:46 -05:00
|
|
|
name: Option<&Name>,
|
2019-11-02 09:18:26 -05:00
|
|
|
receiver_ty: Option<&Canonical<Ty>>,
|
2019-11-26 06:27:33 -06:00
|
|
|
item: AssocItemId,
|
2019-11-02 09:18:26 -05:00
|
|
|
self_ty: &Canonical<Ty>,
|
2021-03-20 13:28:26 -05:00
|
|
|
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);
|
2019-11-02 09:18:26 -05:00
|
|
|
if let Some(name) = name {
|
|
|
|
if &data.name != name {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if let Some(receiver_ty) = receiver_ty {
|
2021-04-03 13:58:42 -05:00
|
|
|
if !data.has_self_param() {
|
2019-11-02 09:18:26 -05:00
|
|
|
return false;
|
|
|
|
}
|
2021-05-16 08:50:28 -05:00
|
|
|
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;
|
|
|
|
}
|
2019-11-02 09:18:26 -05:00
|
|
|
}
|
2021-03-20 13:28:26 -05:00
|
|
|
if let Some(from_module) = visible_from_module {
|
2021-03-24 16:59:59 -05:00
|
|
|
if !db.function_visibility(m).is_visible_from(db.upcast(), from_module) {
|
2021-03-20 14:35:57 -05:00
|
|
|
cov_mark::hit!(autoderef_candidate_not_visible);
|
2021-03-20 13:28:26 -05:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-02 09:18:26 -05:00
|
|
|
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);
|
2019-11-02 09:18:26 -05:00
|
|
|
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(
|
2020-03-13 10:05:46 -05:00
|
|
|
db: &dyn HirDatabase,
|
2021-05-16 08:50:28 -05:00
|
|
|
env: Arc<TraitEnvironment>,
|
2019-12-02 11:12:49 -06:00
|
|
|
impl_id: ImplId,
|
2019-12-03 07:59:29 -06:00
|
|
|
self_ty: &Canonical<Ty>,
|
2021-03-15 15:02:34 -05:00
|
|
|
) -> Option<Substitution> {
|
2020-03-01 07:31:35 -06:00
|
|
|
// 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);
|
2021-04-03 15:18:02 -05:00
|
|
|
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)
|
2020-04-05 11:24:18 -05:00
|
|
|
.build();
|
2021-04-05 11:49:26 -05:00
|
|
|
let self_ty_with_vars = db.impl_self_ty(impl_id).substitute(&Interner, &vars);
|
2021-03-21 14:05:38 -05:00
|
|
|
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,
|
|
|
|
))
|
2021-04-01 14:04:02 -05:00
|
|
|
.take(vars.len(&Interner)),
|
2021-03-21 14:05:38 -05:00
|
|
|
);
|
|
|
|
let tys = Canonical {
|
|
|
|
binders: CanonicalVarKinds::from_iter(&Interner, kinds),
|
|
|
|
value: (self_ty_with_vars, self_ty.value.clone()),
|
|
|
|
};
|
2021-05-16 08:50:28 -05:00
|
|
|
let substs = super::infer::unify(db, env, &tys)?;
|
2020-03-10 14:56:26 -05:00
|
|
|
// 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))
|
2020-03-10 14:56:26 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/// This replaces any 'free' Bound vars in `s` (i.e. those with indices past
|
2021-03-13 07:44:51 -06:00
|
|
|
/// 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(
|
2020-03-13 10:05:46 -05:00
|
|
|
db: &dyn HirDatabase,
|
2021-05-16 08:50:28 -05:00
|
|
|
env: Arc<TraitEnvironment>,
|
2019-12-02 11:12:49 -06:00
|
|
|
function_id: FunctionId,
|
|
|
|
self_ty: &Canonical<Ty>,
|
|
|
|
) -> Option<Ty> {
|
2020-03-13 10:05:46 -05:00
|
|
|
let substs = match function_id.lookup(db.upcast()).container {
|
2021-04-03 15:18:02 -05:00
|
|
|
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(),
|
2020-12-04 11:41:37 -06:00
|
|
|
AssocContainerId::ImplId(impl_id) => {
|
2021-06-12 22:54:16 -05:00
|
|
|
let impl_substs = inherent_impl_substs(db, env, impl_id, self_ty)?;
|
2021-04-03 15:18:02 -05:00
|
|
|
TyBuilder::subst_for_def(db, function_id)
|
2020-12-04 11:41:37 -06:00
|
|
|
.use_parent_substs(&impl_substs)
|
|
|
|
.fill_with_unknown()
|
|
|
|
.build()
|
|
|
|
}
|
2021-03-09 11:27:16 -06:00
|
|
|
AssocContainerId::ModuleId(_) => unreachable!(),
|
2019-12-02 11:12:49 -06:00
|
|
|
};
|
|
|
|
let sig = db.callable_item_signature(function_id.into());
|
2021-04-05 11:49:26 -05:00
|
|
|
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>,
|
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 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());
|
2021-05-16 08:50:28 -05:00
|
|
|
let solution = db.trait_solve(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>,
|
|
|
|
krate: CrateId,
|
|
|
|
trait_: TraitId,
|
|
|
|
) -> bool {
|
|
|
|
let goal = generic_implements_goal(db, env, trait_, ty.clone());
|
2021-05-16 08:50:28 -05:00
|
|
|
let solution = db.trait_solve(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,
|
2019-05-01 10:57:56 -05: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_)
|
2019-09-26 14:37:03 -05:00
|
|
|
.push(self_ty.value)
|
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();
|
2021-03-21 14:05:38 -05:00
|
|
|
kinds.extend(
|
|
|
|
iter::repeat(chalk_ir::WithKind::new(
|
|
|
|
chalk_ir::VariableKind::Ty(chalk_ir::TyVariableKind::General),
|
|
|
|
UniverseIndex::ROOT,
|
|
|
|
))
|
2021-04-03 14:50:52 -05:00
|
|
|
.take(trait_ref.substitution.len(&Interner) - 1),
|
2021-03-21 14:05:38 -05:00
|
|
|
);
|
2021-03-20 05:23:59 -05:00
|
|
|
let obligation = trait_ref.cast(&Interner);
|
2021-03-21 14:05:38 -05:00
|
|
|
Canonical {
|
|
|
|
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(
|
2020-03-13 10:05:46 -05:00
|
|
|
db: &dyn HirDatabase,
|
2020-02-29 15:01:36 -06:00
|
|
|
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))
|
|
|
|
{
|
2021-03-21 14:05:38 -05:00
|
|
|
let kinds = deref_chain.last().unwrap().binders.clone();
|
2021-03-13 07:44:51 -06:00
|
|
|
let unsized_ty = TyKind::Slice(parameters.clone()).intern(&Interner);
|
2021-03-21 14:05:38 -05:00
|
|
|
deref_chain.push(Canonical { value: unsized_ty, binders: kinds })
|
2020-02-29 15:01:36 -06:00
|
|
|
}
|
|
|
|
deref_chain
|
|
|
|
}
|