env: Arc<TraitEnvironment>,
krate: CrateId,
traits_in_scope: &FxHashSet<TraitId>,
+ visible_from_module: Option<ModuleId>,
name: &Name,
) -> Option<(Ty, FunctionId)> {
iterate_method_candidates(
env,
krate,
&traits_in_scope,
+ visible_from_module,
Some(name),
LookupMode::MethodCall,
|ty, f| match f {
env: Arc<TraitEnvironment>,
krate: CrateId,
traits_in_scope: &FxHashSet<TraitId>,
+ visible_from_module: Option<ModuleId>,
name: Option<&Name>,
mode: LookupMode,
mut callback: impl FnMut(&Ty, AssocItemId) -> Option<T>,
env,
krate,
traits_in_scope,
+ visible_from_module,
name,
mode,
&mut |ty, item| {
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,
env.clone(),
krate,
traits_in_scope,
+ visible_from_module,
name,
callback,
) {
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 {
env.clone(),
krate,
&traits_in_scope,
+ visible_from_module,
name,
&mut callback,
) {
env.clone(),
krate,
&traits_in_scope,
+ visible_from_module,
name,
&mut callback,
) {
env,
krate,
&traits_in_scope,
+ visible_from_module,
name,
&mut callback,
) {
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 {
// be found in any of the derefs of receiver_ty, so we have to go through
// that.
for self_ty in std::iter::once(receiver_ty).chain(rest_of_deref_chain) {
- if iterate_inherent_methods(self_ty, db, name, Some(receiver_ty), krate, &mut callback) {
+ if iterate_inherent_methods(
+ self_ty,
+ db,
+ name,
+ Some(receiver_ty),
+ krate,
+ visible_from_module,
+ &mut callback,
+ ) {
return true;
}
}
name: Option<&Name>,
mut callback: &mut dyn FnMut(&Ty, AssocItemId) -> bool,
) -> bool {
- if iterate_inherent_methods(self_ty, db, name, None, krate, &mut callback) {
+ if iterate_inherent_methods(self_ty, db, name, None, krate, None, &mut callback) {
return true;
}
iterate_trait_method_candidates(self_ty, db, env, krate, traits_in_scope, name, None, callback)
// iteration
let mut known_implemented = false;
for (_name, item) in data.items.iter() {
- if !is_valid_candidate(db, name, receiver_ty, *item, self_ty) {
+ if !is_valid_candidate(db, name, receiver_ty, *item, self_ty, None) {
continue;
}
if !known_implemented {
name: Option<&Name>,
receiver_ty: Option<&Canonical<Ty>>,
krate: CrateId,
+ visible_from_module: Option<ModuleId>,
callback: &mut dyn FnMut(&Ty, AssocItemId) -> bool,
) -> bool {
let def_crates = match self_ty.value.def_crates(db, krate) {
for &impl_def in impls.for_self_ty(&self_ty.value) {
for &item in db.impl_data(impl_def).items.iter() {
- if !is_valid_candidate(db, name, receiver_ty, item, self_ty) {
+ if !is_valid_candidate(db, name, receiver_ty, item, self_ty, visible_from_module) {
continue;
}
// we have to check whether the self type unifies with the type
receiver_ty: Option<&Canonical<Ty>>,
item: AssocItemId,
self_ty: &Canonical<Ty>,
+ visible_from_module: Option<ModuleId>,
) -> bool {
match item {
AssocItemId::FunctionId(m) => {
return false;
}
}
+ if let Some(from_module) = visible_from_module {
+ if !db.fn_visibility(m).is_visible_from(db.upcast(), from_module) {
+ return false;
+ }
+ }
+
true
}
AssocItemId::ConstId(c) => {