add notable_traits and is_notable_trait field in import structs

Author: dfireBird

crates/hir-def/src/attr.rs

@@ -207,6 +207,13 @@ impl Attrs {
         })
     }
 
+    pub fn has_doc_notable_trait(&self) -> bool {
+        self.by_key("doc").tt_values().any(|tt| {
+            tt.delimiter.kind == DelimiterKind::Parenthesis &&
+                matches!(&*tt.token_trees, [tt::TokenTree::Leaf(tt::Leaf::Ident(ident))] if ident.text == "notable_trait")
+        })
+    }
+
     pub fn doc_exprs(&self) -> impl Iterator<Item = DocExpr> + '_ {
         self.by_key("doc").tt_values().map(DocExpr::parse)
     }

crates/hir-def/src/import_map.rs

@@ -31,6 +31,8 @@ pub struct ImportInfo {
     pub container: ModuleId,
     /// Whether this item is annotated with `#[doc(hidden)]`.
     pub is_doc_hidden: bool,
+    /// Whether this item is annoated with `#[doc(hidden)]`
+    pub is_doc_notable_trait: bool,
     /// Whether this item is annotated with `#[unstable(..)]`.
     pub is_unstable: bool,
 }
@@ -51,6 +53,7 @@ pub struct ImportMap {
     /// same name right after each other. This allows us to find all items after the FST gives us
     /// the index of the first one.
     importables: Vec<ItemInNs>,
+    notable_traits: Vec<ItemInNs>,
     fst: fst::Map<Vec<u8>>,
 }
 
@@ -78,6 +81,18 @@ impl ImportMap {
 
         let map = collect_import_map(db, krate);
 
+        let notable_traits: Vec<_> = map
+            .iter()
+            .filter_map(|(&item, (info, _))| {
+                let is_notable_trait = info.iter().any(|info| info.is_doc_notable_trait);
+                if is_notable_trait {
+                    Some(item)
+                } else {
+                    None
+                }
+            })
+            .collect();
+
         let mut importables: Vec<_> = map
             .iter()
             // We've only collected items, whose name cannot be tuple field.
@@ -104,6 +119,7 @@ impl ImportMap {
 
         Arc::new(ImportMap {
             map,
+            notable_traits,
             fst: builder.into_map(),
             importables: importables.into_iter().map(|(item, _, _)| item).collect(),
         })
@@ -160,15 +176,17 @@ fn collect_import_map(db: &dyn DefDatabase, krate: CrateId) -> ImportMapIndex {
                         ItemInNs::Macros(id) => Some(id.into()),
                     }
                 };
-                let (is_doc_hidden, is_unstable) = attr_id.map_or((false, false), |attr_id| {
-                    let attrs = db.attrs(attr_id);
-                    (attrs.has_doc_hidden(), attrs.is_unstable())
-                });
+                let (is_doc_hidden, is_doc_notable_trait, is_unstable) =
+                    attr_id.map_or((false, false, false), |attr_id| {
+                        let attrs = db.attrs(attr_id);
+                        (attrs.has_doc_hidden(), attrs.has_doc_notable_trait(), attrs.is_unstable())
+                    });
 
                 let import_info = ImportInfo {
                     name: name.clone(),
                     container: module,
                     is_doc_hidden,
+                    is_doc_notable_trait,
                     is_unstable,
                 };
 
@@ -228,6 +246,7 @@ fn collect_trait_assoc_items(
             container: trait_import_info.container,
             name: assoc_item_name.clone(),
             is_doc_hidden: attrs.has_doc_hidden(),
+            is_doc_notable_trait: attrs.has_doc_notable_trait(),
             is_unstable: attrs.is_unstable(),
         };