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;
|
2020-08-13 09:25:38 -05:00
|
|
|
use base_db::CrateId;
|
2021-03-21 14:05:38 -05:00
|
|
|
use chalk_ir::{cast::Cast, Mutability, UniverseIndex};
|
2019-11-26 06:27:33 -06:00
|
|
|
use hir_def::{
|
2021-03-01 14:57:39 -06:00
|
|
|
lang_item::LangItemTarget, AssocContainerId, AssocItemId, FunctionId, GenericDefId, HasModule,
|
2021-03-13 10:23:19 -06:00
|
|
|
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},
|
2020-07-11 12:12:10 -05:00
|
|
|
utils::all_super_traits,
|
2021-03-21 14:05:38 -05:00
|
|
|
AdtId, Canonical, CanonicalVarKinds, DebruijnIndex, FnPointer, FnSig, ForeignDefId,
|
2021-04-03 14:50:52 -05:00
|
|
|
InEnvironment, Interner, Scalar, Substitution, TraitEnvironment, Ty, TyBuilder, TyKind,
|
2021-03-21 14:05:38 -05:00
|
|
|
TypeWalk,
|
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-02-28 12:13:37 -06:00
|
|
|
Str,
|
|
|
|
Slice,
|
|
|
|
Array,
|
|
|
|
Never,
|
|
|
|
RawPtr(Mutability),
|
|
|
|
Scalar(Scalar),
|
2021-03-01 14:57:39 -06:00
|
|
|
Adt(hir_def::AdtId),
|
2021-02-08 12:13:54 -06:00
|
|
|
Dyn(TraitId),
|
2021-02-28 13:39:43 -06:00
|
|
|
Tuple(usize),
|
2021-03-13 10:23:19 -06:00
|
|
|
ForeignType(ForeignDefId),
|
2021-02-28 15:12:07 -06:00
|
|
|
FnPtr(usize, FnSig),
|
2019-01-07 06:44:54 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
impl TyFingerprint {
|
|
|
|
/// Creates a TyFingerprint for looking up an impl. Only certain types can
|
|
|
|
/// have 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.
|
2021-03-15 07:49:21 -05:00
|
|
|
pub fn for_impl(ty: &Ty) -> Option<TyFingerprint> {
|
2021-04-03 06:08:29 -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,
|
|
|
|
TyKind::Scalar(scalar) => TyFingerprint::Scalar(scalar),
|
|
|
|
TyKind::Adt(AdtId(adt), _) => TyFingerprint::Adt(adt),
|
|
|
|
TyKind::Tuple(cardinality, _) => TyFingerprint::Tuple(cardinality),
|
|
|
|
TyKind::Raw(mutability, ..) => TyFingerprint::RawPtr(mutability),
|
|
|
|
TyKind::ForeignType(alias_id, ..) => TyFingerprint::ForeignType(alias_id),
|
|
|
|
TyKind::Function(FnPointer { num_args, sig, .. }) => {
|
|
|
|
TyFingerprint::FnPtr(num_args, sig)
|
|
|
|
}
|
|
|
|
TyKind::Dyn(_) => ty.dyn_trait().map(|trait_| TyFingerprint::Dyn(trait_))?,
|
2021-02-28 12:13:37 -06:00
|
|
|
_ => 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-01-20 08:41:18 -06:00
|
|
|
for (_module_id, module_data) in crate_def_map.modules() {
|
2020-07-01 10:15:20 -05:00
|
|
|
for impl_id in module_data.scope.impls() {
|
|
|
|
let target_trait = match db.impl_trait(impl_id) {
|
2021-03-18 15:53:19 -05:00
|
|
|
Some(tr) => tr.value.hir_trait_id(),
|
2020-07-01 10:15:20 -05:00
|
|
|
None => continue,
|
|
|
|
};
|
|
|
|
let self_ty = db.impl_self_ty(impl_id);
|
|
|
|
let self_ty_fp = TyFingerprint::for_impl(&self_ty.value);
|
|
|
|
impls
|
|
|
|
.map
|
|
|
|
.entry(target_trait)
|
|
|
|
.or_default()
|
|
|
|
.entry(self_ty_fp)
|
|
|
|
.or_default()
|
|
|
|
.push(impl_id);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Arc::new(impls)
|
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.
|
|
|
|
pub fn for_self_ty(&self, fp: TyFingerprint) -> impl Iterator<Item = ImplId> + '_ {
|
|
|
|
self.map
|
|
|
|
.values()
|
|
|
|
.flat_map(move |impls| impls.get(&None).into_iter().chain(impls.get(&Some(fp))))
|
|
|
|
.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> {
|
|
|
|
let mut map: FxHashMap<_, Vec<_>> = FxHashMap::default();
|
|
|
|
|
|
|
|
let crate_def_map = db.crate_def_map(krate);
|
2021-01-20 08:41:18 -06:00
|
|
|
for (_module_id, module_data) in crate_def_map.modules() {
|
2020-07-01 10:15:20 -05:00
|
|
|
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);
|
|
|
|
if let Some(fp) = TyFingerprint::for_impl(&self_ty.value) {
|
|
|
|
map.entry(fp).or_default().push(impl_id);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Arc::new(Self { map })
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn for_self_ty(&self, self_ty: &Ty) -> &[ImplId] {
|
|
|
|
match TyFingerprint::for_impl(self_ty) {
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2019-11-26 13:56:07 -06:00
|
|
|
impl Ty {
|
2019-11-27 08:46:02 -06:00
|
|
|
pub fn def_crates(
|
2019-11-26 13:56:07 -06:00
|
|
|
&self,
|
2020-03-13 10:05:46 -05:00
|
|
|
db: &dyn HirDatabase,
|
2019-11-26 13:56:07 -06:00
|
|
|
cur_crate: CrateId,
|
2021-03-25 14:03:20 -05:00
|
|
|
) -> Option<ArrayVec<CrateId, 2>> {
|
2019-11-26 13:56:07 -06:00
|
|
|
// 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-02-08 12:13:54 -06:00
|
|
|
let mod_to_crate_ids = |module: ModuleId| Some(std::iter::once(module.krate()).collect());
|
|
|
|
|
2021-04-03 06:08:29 -05:00
|
|
|
let lang_item_targets = match self.kind(&Interner) {
|
2021-03-13 07:44:51 -06:00
|
|
|
TyKind::Adt(AdtId(def_id), _) => {
|
2021-02-28 12:13:37 -06:00
|
|
|
return mod_to_crate_ids(def_id.module(db.upcast()));
|
|
|
|
}
|
2021-03-13 10:23:19 -06:00
|
|
|
TyKind::ForeignType(id) => {
|
|
|
|
return mod_to_crate_ids(
|
|
|
|
from_foreign_def_id(*id).lookup(db.upcast()).module(db.upcast()),
|
|
|
|
);
|
2021-02-28 12:13:37 -06:00
|
|
|
}
|
2021-03-13 07:44:51 -06:00
|
|
|
TyKind::Scalar(Scalar::Bool) => lang_item_crate!("bool"),
|
|
|
|
TyKind::Scalar(Scalar::Char) => lang_item_crate!("char"),
|
|
|
|
TyKind::Scalar(Scalar::Float(f)) => match f {
|
2021-02-28 12:13:37 -06:00
|
|
|
// 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"),
|
2019-07-08 13:37:29 -05:00
|
|
|
},
|
2021-03-13 07:44:51 -06:00
|
|
|
&TyKind::Scalar(Scalar::Int(t)) => {
|
2021-02-28 12:13:37 -06:00
|
|
|
lang_item_crate!(primitive::int_ty_to_string(t))
|
|
|
|
}
|
2021-03-13 07:44:51 -06:00
|
|
|
&TyKind::Scalar(Scalar::Uint(t)) => {
|
2021-02-28 12:13:37 -06:00
|
|
|
lang_item_crate!(primitive::uint_ty_to_string(t))
|
|
|
|
}
|
2021-03-13 07:44:51 -06:00
|
|
|
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(_) => {
|
2021-02-08 12:13:54 -06:00
|
|
|
return self.dyn_trait().and_then(|trait_| {
|
|
|
|
mod_to_crate_ids(GenericDefId::TraitId(trait_).module(db.upcast()))
|
|
|
|
});
|
|
|
|
}
|
2019-11-23 03:58:01 -06:00
|
|
|
_ => return None,
|
2019-11-26 13:56:07 -06:00
|
|
|
};
|
|
|
|
let res = lang_item_targets
|
|
|
|
.into_iter()
|
|
|
|
.filter_map(|it| match it {
|
2020-02-29 14:24:40 -06:00
|
|
|
LangItemTarget::ImplDefId(it) => Some(it),
|
2019-11-26 13:56:07 -06:00
|
|
|
_ => None,
|
|
|
|
})
|
2021-03-09 12:09:02 -06:00
|
|
|
.map(|it| it.lookup(db.upcast()).container.krate())
|
2019-11-26 13:56:07 -06:00
|
|
|
.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,
|
|
|
|
&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(
|
|
|
|
&ty,
|
|
|
|
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,
|
|
|
|
&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-03-14 11:40:55 -05:00
|
|
|
value: TyKind::Ref(Mutability::Not, 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,
|
|
|
|
&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-03-14 11:40:55 -05:00
|
|
|
value: TyKind::Ref(Mutability::Mut, 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,
|
|
|
|
&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,
|
|
|
|
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,
|
|
|
|
&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-03-20 13:48:35 -05:00
|
|
|
if iterate_inherent_methods(self_ty, db, 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 {
|
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
|
|
|
|
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-03-20 13:28:26 -05:00
|
|
|
if !is_valid_candidate(db, 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());
|
2020-02-18 06:53:02 -06:00
|
|
|
if db.trait_solve(krate, goal).is_none() {
|
2019-10-31 13:28:33 -05:00
|
|
|
continue 'traits;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
known_implemented = true;
|
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,
|
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 {
|
|
|
|
let def_crates = match self_ty.value.def_crates(db, krate) {
|
|
|
|
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-03-20 13:28:26 -05:00
|
|
|
if !is_valid_candidate(db, 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
|
2020-02-29 14:24:40 -06:00
|
|
|
if receiver_ty.is_none() && inherent_impl_substs(db, 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;
|
|
|
|
}
|
2020-06-24 10:45:38 -05:00
|
|
|
if callback(&self_ty.value, item) {
|
|
|
|
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());
|
|
|
|
if db.trait_solve(krate, goal).is_some() {
|
|
|
|
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,
|
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;
|
|
|
|
}
|
2019-12-02 11:12:49 -06:00
|
|
|
let transformed_receiver_ty = match transform_receiver_ty(db, m, self_ty) {
|
|
|
|
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,
|
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-03 15:18:02 -05:00
|
|
|
let vars = TyBuilder::subst_for_def(db, impl_id)
|
2021-03-21 14:05:38 -05:00
|
|
|
.fill_with_bound_vars(DebruijnIndex::INNERMOST, self_ty.binders.len(&Interner))
|
2020-04-05 11:24:18 -05:00
|
|
|
.build();
|
2019-12-02 11:12:49 -06:00
|
|
|
let self_ty_with_vars = db.impl_self_ty(impl_id).subst(&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()),
|
|
|
|
};
|
2020-06-28 14:17:27 -05:00
|
|
|
let substs = super::infer::unify(&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-01 14:04:02 -05:00
|
|
|
substs
|
|
|
|
.map(|s| fallback_bound_vars(s.suffix(vars.len(&Interner)), self_ty.binders.len(&Interner)))
|
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 {
|
2020-03-10 14:56:26 -05:00
|
|
|
s.fold_binders(
|
|
|
|
&mut |ty, binders| {
|
2021-04-03 06:08:29 -05:00
|
|
|
if let TyKind::BoundVar(bound) = ty.kind(&Interner) {
|
2020-04-05 11:24:18 -05:00
|
|
|
if bound.index >= num_vars_to_keep && bound.debruijn >= binders {
|
2021-04-05 07:37:11 -05:00
|
|
|
TyKind::Error.intern(&Interner)
|
2020-03-10 14:56:26 -05:00
|
|
|
} else {
|
|
|
|
ty
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ty
|
|
|
|
}
|
|
|
|
},
|
2020-04-05 11:24:18 -05:00
|
|
|
DebruijnIndex::INNERMOST,
|
2020-03-10 14:56:26 -05:00
|
|
|
)
|
2019-12-02 11:12:49 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
fn transform_receiver_ty(
|
2020-03-13 10:05:46 -05:00
|
|
|
db: &dyn HirDatabase,
|
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) => {
|
|
|
|
let impl_substs = inherent_impl_substs(db, 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());
|
2020-01-25 16:38:33 -06:00
|
|
|
Some(sig.value.params()[0].clone().subst_bound_vars(&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());
|
2020-02-18 06:53:02 -06:00
|
|
|
let solution = db.trait_solve(krate, goal);
|
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());
|
|
|
|
let solution = db.trait_solve(krate, goal);
|
|
|
|
|
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-03-21 14:19:07 -05:00
|
|
|
value: InEnvironment::new(env.env.clone(), 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-03 06:08:29 -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
|
|
|
|
}
|