Merge #9637

9637: Overhaul doc_links testing infra r=Veykril a=Veykril

and fix several issues with current implementation.

Fixes #9617

Co-authored-by: Lukas Wirth <[email protected]>

Author: bors[bot]

crates/hir/src/attrs.rs

@@ -114,16 +114,15 @@ fn resolve_doc_path(
     let path = ast::Path::parse(link).ok()?;
     let modpath = ModPath::from_src(db.upcast(), path, &Hygiene::new_unhygienic()).unwrap();
     let resolved = resolver.resolve_module_path_in_items(db.upcast(), &modpath);
-    if resolved == PerNs::none() {
-        if let Some(trait_id) = resolver.resolve_module_path_in_trait_items(db.upcast(), &modpath) {
-            return Some(ModuleDefId::TraitId(trait_id));
-        };
-    }
-    let def = match ns {
-        Some(Namespace::Types) => resolved.take_types()?,
-        Some(Namespace::Values) => resolved.take_values()?,
-        Some(Namespace::Macros) => return None,
-        None => resolved.iter_items().find_map(|it| it.as_module_def_id())?,
+    let resolved = if resolved == PerNs::none() {
+        resolver.resolve_module_path_in_trait_assoc_items(db.upcast(), &modpath)?
+    } else {
+        resolved
     };
-    Some(def)
+    match ns {
+        Some(Namespace::Types) => resolved.take_types(),
+        Some(Namespace::Values) => resolved.take_values(),
+        Some(Namespace::Macros) => None,
+        None => resolved.iter_items().find_map(|it| it.as_module_def_id()),
+    }
 }

crates/hir/src/lib.rs

@@ -295,12 +295,19 @@ impl ModuleDef {
     }
 
     pub fn canonical_path(&self, db: &dyn HirDatabase) -> Option<String> {
-        let mut segments = vec![self.name(db)?.to_string()];
+        let mut segments = vec![self.name(db)?];
         for m in self.module(db)?.path_to_root(db) {
-            segments.extend(m.name(db).map(|it| it.to_string()))
+            segments.extend(m.name(db))
         }
         segments.reverse();
-        Some(segments.join("::"))
+        Some(segments.into_iter().join("::"))
+    }
+
+    pub fn canonical_module_path(
+        &self,
+        db: &dyn HirDatabase,
+    ) -> Option<impl Iterator<Item = Module>> {
+        self.module(db).map(|it| it.path_to_root(db).into_iter().rev())
     }
 
     pub fn name(self, db: &dyn HirDatabase) -> Option<Name> {

crates/hir_def/src/resolver.rs

@@ -20,10 +20,10 @@ use crate::{
     path::{ModPath, PathKind},
     per_ns::PerNs,
     visibility::{RawVisibility, Visibility},
-    AdtId, AssocContainerId, ConstId, ConstParamId, DefWithBodyId, EnumId, EnumVariantId,
-    FunctionId, GenericDefId, GenericParamId, HasModule, ImplId, LifetimeParamId, LocalModuleId,
-    Lookup, ModuleDefId, ModuleId, StaticId, StructId, TraitId, TypeAliasId, TypeParamId,
-    VariantId,
+    AdtId, AssocContainerId, AssocItemId, ConstId, ConstParamId, DefWithBodyId, EnumId,
+    EnumVariantId, FunctionId, GenericDefId, GenericParamId, HasModule, ImplId, LifetimeParamId,
+    LocalModuleId, Lookup, ModuleDefId, ModuleId, StaticId, StructId, TraitId, TypeAliasId,
+    TypeParamId, VariantId,
 };
 
 #[derive(Debug, Clone, Default)]
@@ -144,15 +144,28 @@ impl Resolver {
         self.resolve_module_path(db, path, BuiltinShadowMode::Module)
     }
 
-    pub fn resolve_module_path_in_trait_items(
+    pub fn resolve_module_path_in_trait_assoc_items(
         &self,
         db: &dyn DefDatabase,
         path: &ModPath,
-    ) -> Option<TraitId> {
+    ) -> Option<PerNs> {
         let (item_map, module) = self.module_scope()?;
-        let (module_res, ..) = item_map.resolve_path(db, module, path, BuiltinShadowMode::Module);
+        let (module_res, idx) = item_map.resolve_path(db, module, path, BuiltinShadowMode::Module);
         match module_res.take_types()? {
-            ModuleDefId::TraitId(it) => Some(it),
+            ModuleDefId::TraitId(it) => {
+                let idx = idx?;
+                let unresolved = &path.segments()[idx..];
+                let assoc = match unresolved {
+                    [it] => it,
+                    _ => return None,
+                };
+                let &(_, assoc) = db.trait_data(it).items.iter().find(|(n, _)| n == assoc)?;
+                Some(match assoc {
+                    AssocItemId::FunctionId(it) => PerNs::values(it.into(), Visibility::Public),
+                    AssocItemId::ConstId(it) => PerNs::values(it.into(), Visibility::Public),
+                    AssocItemId::TypeAliasId(it) => PerNs::types(it.into(), Visibility::Public),
+                })
+            }
             _ => None,
         }
     }