Allow crate authors to control completion of their things

Via the new `#[rust_analyzer::do_not_complete(...)]` attribute.

Also fix a bug with existing settings for that where the paths wouldn't resolve correctly.

Author: ChayimFriedman2

crates/hir-def/src/data.rs

@@ -49,6 +49,8 @@ bitflags! {
         const IS_MANUALLY_DROP = 1 << 6;
         /// Indicates whether this struct is `UnsafeCell`.
         const IS_UNSAFE_CELL   = 1 << 7;
+        /// `#[rust_analyzer::do_not_complete(flyimport)]`
+        const DO_NOT_COMPLETE_FLYIMPORT = 1 << 7;
     }
 }
 
@@ -58,6 +60,8 @@ pub struct EnumData {
     pub repr: Option<ReprOptions>,
     pub visibility: RawVisibility,
     pub rustc_has_incoherent_inherent_impls: bool,
+    /// `#[rust_analyzer::do_not_complete(flyimport)]`.
+    pub do_not_complete_flyimport: bool,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -208,6 +212,23 @@ impl StructData {
             }
         }
 
+        for ra_attr in attrs.rust_analyzer_tool() {
+            let segments = ra_attr.path.segments();
+            if segments.len() != 2 {
+                continue;
+            }
+            let action = segments[1].symbol();
+            if *action == sym::do_not_complete {
+                if let Some([tt::TokenTree::Leaf(tt::Leaf::Ident(ident))]) =
+                    ra_attr.token_tree_value().map(|tt| tt.token_trees().flat_tokens())
+                {
+                    if ident.sym == sym::flyimport {
+                        flags |= StructFlags::DO_NOT_COMPLETE_FLYIMPORT;
+                    }
+                }
+            }
+        }
+
         let strukt = &item_tree[loc.id.value];
         Arc::new(StructData {
             name: strukt.name.clone(),
@@ -225,13 +246,31 @@ impl StructData {
         let repr = repr_from_value(db, krate, &item_tree, ModItem::from(loc.id.value).into());
         let attrs = item_tree.attrs(db, krate, ModItem::from(loc.id.value).into());
         let mut flags = StructFlags::NO_FLAGS;
+
         if attrs.by_key(&sym::rustc_has_incoherent_inherent_impls).exists() {
             flags |= StructFlags::IS_RUSTC_HAS_INCOHERENT_INHERENT_IMPL;
         }
         if attrs.by_key(&sym::fundamental).exists() {
             flags |= StructFlags::IS_FUNDAMENTAL;
         }
 
+        for ra_attr in attrs.rust_analyzer_tool() {
+            let segments = ra_attr.path.segments();
+            if segments.len() != 2 {
+                continue;
+            }
+            let action = segments[1].symbol();
+            if *action == sym::do_not_complete {
+                if let Some([tt::TokenTree::Leaf(tt::Leaf::Ident(ident))]) =
+                    ra_attr.token_tree_value().map(|tt| tt.token_trees().flat_tokens())
+                {
+                    if ident.sym == sym::flyimport {
+                        flags |= StructFlags::DO_NOT_COMPLETE_FLYIMPORT;
+                    }
+                }
+            }
+        }
+
         let union = &item_tree[loc.id.value];
 
         Arc::new(StructData {
@@ -289,10 +328,28 @@ impl EnumData {
         let krate = loc.container.krate;
         let item_tree = loc.id.item_tree(db);
         let repr = repr_from_value(db, krate, &item_tree, ModItem::from(loc.id.value).into());
-        let rustc_has_incoherent_inherent_impls = item_tree
-            .attrs(db, loc.container.krate, ModItem::from(loc.id.value).into())
-            .by_key(&sym::rustc_has_incoherent_inherent_impls)
-            .exists();
+        let attrs = item_tree.attrs(db, loc.container.krate, ModItem::from(loc.id.value).into());
+
+        let rustc_has_incoherent_inherent_impls =
+            attrs.by_key(&sym::rustc_has_incoherent_inherent_impls).exists();
+
+        let mut do_not_complete_flyimport = false;
+        for ra_attr in attrs.rust_analyzer_tool() {
+            let segments = ra_attr.path.segments();
+            if segments.len() != 2 {
+                continue;
+            }
+            let action = segments[1].symbol();
+            if *action == sym::do_not_complete {
+                if let Some([tt::TokenTree::Leaf(tt::Leaf::Ident(ident))]) =
+                    ra_attr.token_tree_value().map(|tt| tt.token_trees().flat_tokens())
+                {
+                    if ident.sym == sym::flyimport {
+                        do_not_complete_flyimport = true;
+                    }
+                }
+            }
+        }
 
         let enum_ = &item_tree[loc.id.value];
 
@@ -301,6 +358,7 @@ impl EnumData {
             repr,
             visibility: item_tree[enum_.visibility].clone(),
             rustc_has_incoherent_inherent_impls,
+            do_not_complete_flyimport,
         })
     }
 

crates/hir-def/src/data/adt.rs

@@ -460,6 +460,20 @@ impl ItemScope {
     pub fn iter_macro_invoc(&self) -> impl Iterator<Item = (&AstId<ast::MacroCall>, &MacroCallId)> {
         self.macro_invocations.iter()
     }
+
+    pub fn get_including_legacy_macros(&self, name: &Name) -> PerNs {
+        PerNs {
+            types: self.types.get(name).copied(),
+            values: self.values.get(name).copied(),
+            macros: self.macros.get(name).copied().or_else(|| {
+                self.legacy_macros.get(name).and_then(|macros| macros.first()).map(|&m| Item {
+                    def: m,
+                    vis: Visibility::Public,
+                    import: None,
+                })
+            }),
+        }
+    }
 }
 
 impl ItemScope {

crates/hir-def/src/item_scope.rs

@@ -937,7 +937,7 @@ pub struct Param {
 
 bitflags::bitflags! {
     #[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
-    pub(crate) struct FnFlags: u16 {
+    pub struct FnFlags: u16 {
         const HAS_SELF_PARAM = 1 << 0;
         const HAS_BODY = 1 << 1;
         const HAS_DEFAULT_KW = 1 << 2;
@@ -952,6 +952,9 @@ bitflags::bitflags! {
         /// it if needed.
         const HAS_TARGET_FEATURE = 1 << 8;
         const DEPRECATED_SAFE_2024 = 1 << 9;
+        const RUSTC_ALLOW_INCOHERENT_IMPL = 1 << 10;
+        /// `#[rust_analyzer::do_not_complete(flyimport)]`.
+        const DO_NOT_COMPLETE_FLYIMPORT = 1 << 11;
     }
 }
 
@@ -1024,15 +1027,24 @@ pub struct Const {
 pub struct Static {
     pub name: Name,
     pub visibility: RawVisibilityId,
-    // TODO: use bitflags when we have more flags
-    pub mutable: bool,
-    pub has_safe_kw: bool,
-    pub has_unsafe_kw: bool,
+    pub flags: StaticFlags,
     pub type_ref: TypeRefId,
     pub ast_id: FileAstId<ast::Static>,
     pub types_map: Arc<TypesMap>,
 }
 
+bitflags::bitflags! {
+    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+    pub struct StaticFlags: u8 {
+        const MUTABLE = 1 << 0;
+        const IS_EXTERN = 1 << 1;
+        const HAS_SAFE_KW = 1 << 2;
+        const HAS_UNSAFE_KW = 1 << 3;
+        /// `#[rust_analyzer::do_not_complete(flyimport)]`.
+        const DO_NOT_COMPLETE_FLYIMPORT = 1 << 4;
+    }
+}
+
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct Trait {
     pub name: Name,

crates/hir-def/src/item_tree.rs

@@ -29,8 +29,8 @@ use crate::{
         GenericModItem, Idx, Impl, ImportAlias, Interned, ItemTree, ItemTreeData,
         ItemTreeSourceMaps, ItemTreeSourceMapsBuilder, Macro2, MacroCall, MacroRules, Mod, ModItem,
         ModKind, ModPath, Mutability, Name, Param, Path, Range, RawAttrs, RawIdx, RawVisibilityId,
-        Static, Struct, StructKind, Trait, TraitAlias, TypeAlias, Union, Use, UseTree, UseTreeKind,
-        Variant,
+        Static, StaticFlags, Struct, StructKind, Trait, TraitAlias, TypeAlias, Union, Use, UseTree,
+        UseTreeKind, Variant,
     },
     lower::LowerCtx,
     path::AssociatedTypeBinding,
@@ -620,22 +620,23 @@ impl<'a> Ctx<'a> {
         let name = static_.name()?.as_name();
         let type_ref = TypeRef::from_ast_opt(&mut body_ctx, static_.ty());
         let visibility = self.lower_visibility(static_);
-        let mutable = static_.mut_token().is_some();
-        let has_safe_kw = static_.safe_token().is_some();
-        let has_unsafe_kw = static_.unsafe_token().is_some();
+
+        let mut flags = StaticFlags::empty();
+        if static_.mut_token().is_some() {
+            flags |= StaticFlags::MUTABLE;
+        }
+        if static_.safe_token().is_some() {
+            flags |= StaticFlags::HAS_SAFE_KW;
+        }
+        if static_.unsafe_token().is_some() {
+            flags |= StaticFlags::HAS_UNSAFE_KW;
+        }
+
         let ast_id = self.source_ast_id_map.ast_id(static_);
         types_map.shrink_to_fit();
         types_source_map.shrink_to_fit();
-        let res = Static {
-            name,
-            visibility,
-            mutable,
-            type_ref,
-            ast_id,
-            has_safe_kw,
-            has_unsafe_kw,
-            types_map: Arc::new(types_map),
-        };
+        let res =
+            Static { name, visibility, type_ref, ast_id, flags, types_map: Arc::new(types_map) };
         self.source_maps.statics.push(types_source_map);
         Some(id(self.data().statics.alloc(res)))
     }

crates/hir-def/src/item_tree/lower.rs

@@ -11,8 +11,8 @@ use crate::{
         AttrOwner, Const, DefDatabase, Enum, ExternBlock, ExternCrate, Field, FieldParent,
         FieldsShape, FileItemTreeId, FnFlags, Function, GenericModItem, GenericParams, Impl,
         ItemTree, Macro2, MacroCall, MacroRules, Mod, ModItem, ModKind, Param, Path, RawAttrs,
-        RawVisibilityId, Static, Struct, Trait, TraitAlias, TypeAlias, TypeBound, Union, Use,
-        UseTree, UseTreeKind, Variant,
+        RawVisibilityId, Static, StaticFlags, Struct, Trait, TraitAlias, TypeAlias, TypeBound,
+        Union, Use, UseTree, UseTreeKind, Variant,
     },
     pretty::{print_path, print_type_bounds, print_type_ref},
     type_ref::{TypeRefId, TypesMap},
@@ -408,26 +408,18 @@ impl Printer<'_> {
                 wln!(self, " = _;");
             }
             ModItem::Static(it) => {
-                let Static {
-                    name,
-                    visibility,
-                    mutable,
-                    type_ref,
-                    ast_id,
-                    has_safe_kw,
-                    has_unsafe_kw,
-                    types_map,
-                } = &self.tree[it];
+                let Static { name, visibility, type_ref, ast_id, types_map, flags } =
+                    &self.tree[it];
                 self.print_ast_id(ast_id.erase());
                 self.print_visibility(*visibility);
-                if *has_safe_kw {
+                if flags.contains(StaticFlags::HAS_SAFE_KW) {
                     w!(self, "safe ");
                 }
-                if *has_unsafe_kw {
+                if flags.contains(StaticFlags::HAS_UNSAFE_KW) {
                     w!(self, "unsafe ");
                 }
                 w!(self, "static ");
-                if *mutable {
+                if flags.contains(StaticFlags::MUTABLE) {
                     w!(self, "mut ");
                 }
                 w!(self, "{}: ", name.display(self.db.upcast(), self.edition));

crates/hir-def/src/item_tree/pretty.rs

@@ -355,6 +355,8 @@ pub struct ModuleData {
     pub parent: Option<LocalModuleId>,
     pub children: FxIndexMap<Name, LocalModuleId>,
     pub scope: ItemScope,
+    /// Whether the module has `#[rust_analyzer::do_not_complete(flyimport)]`.
+    pub do_not_complete_flyimport: bool,
 }
 
 impl DefMap {
@@ -388,6 +390,7 @@ impl DefMap {
         let module_data = ModuleData::new(
             ModuleOrigin::CrateRoot { definition: krate.root_file_id() },
             Visibility::Public,
+            false,
         );
 
         let def_map = DefMap::empty(
@@ -413,8 +416,11 @@ impl DefMap {
             ModuleId { krate: module.krate, local_id: Self::ROOT, block: module.block },
             VisibilityExplicitness::Implicit,
         );
-        let module_data =
-            ModuleData::new(ModuleOrigin::BlockExpr { block: ast_id, id: block_id }, visibility);
+        let module_data = ModuleData::new(
+            ModuleOrigin::BlockExpr { block: ast_id, id: block_id },
+            visibility,
+            false,
+        );
 
         let (crate_map, crate_local_map) = db.crate_local_def_map(module.krate);
         let def_map = DefMap::empty(
@@ -714,13 +720,18 @@ impl DefMap {
 }
 
 impl ModuleData {
-    pub(crate) fn new(origin: ModuleOrigin, visibility: Visibility) -> Self {
+    pub(crate) fn new(
+        origin: ModuleOrigin,
+        visibility: Visibility,
+        do_not_complete_flyimport: bool,
+    ) -> Self {
         ModuleData {
             origin,
             visibility,
             parent: None,
             children: Default::default(),
             scope: ItemScope::default(),
+            do_not_complete_flyimport,
         }
     }
 

crates/hir-def/src/nameres.rs

@@ -2060,6 +2060,7 @@ impl ModCollector<'_, '_> {
                     None,
                     &self.item_tree[module.visibility],
                     module_id,
+                    attrs,
                 );
 
                 let Some(mod_dir) =
@@ -2113,6 +2114,7 @@ impl ModCollector<'_, '_> {
                                     Some((file_id, is_mod_rs)),
                                     &self.item_tree[module.visibility],
                                     module_id,
+                                    attrs,
                                 );
                                 ModCollector {
                                     def_collector: self.def_collector,
@@ -2141,6 +2143,7 @@ impl ModCollector<'_, '_> {
                             None,
                             &self.item_tree[module.visibility],
                             module_id,
+                            attrs,
                         );
                         self.def_collector.def_map.diagnostics.push(
                             DefDiagnostic::unresolved_module(self.module_id, ast_id, candidates),
@@ -2158,6 +2161,7 @@ impl ModCollector<'_, '_> {
         definition: Option<(EditionedFileId, bool)>,
         visibility: &crate::visibility::RawVisibility,
         mod_tree_id: FileItemTreeId<Mod>,
+        attrs: &Attrs,
     ) -> LocalModuleId {
         let def_map = &mut self.def_collector.def_map;
         let vis = def_map
@@ -2185,8 +2189,26 @@ impl ModCollector<'_, '_> {
             },
         };
 
+        let mut do_not_complete_flyimport = false;
+        for ra_attr in attrs.rust_analyzer_tool() {
+            let segments = ra_attr.path.segments();
+            if segments.len() != 2 {
+                continue;
+            }
+            let action = segments[1].symbol();
+            if *action == sym::do_not_complete {
+                if let Some([tt::TokenTree::Leaf(tt::Leaf::Ident(ident))]) =
+                    ra_attr.token_tree_value().map(|tt| tt.token_trees().flat_tokens())
+                {
+                    if ident.sym == sym::flyimport {
+                        do_not_complete_flyimport = true;
+                    }
+                }
+            }
+        }
+
         let modules = &mut def_map.modules;
-        let res = modules.alloc(ModuleData::new(origin, vis));
+        let res = modules.alloc(ModuleData::new(origin, vis, do_not_complete_flyimport));
         modules[res].parent = Some(self.module_id);
 
         if let Some((target, source)) = Self::borrow_modules(modules.as_mut(), res, self.module_id)
@@ -2615,7 +2637,7 @@ mod tests {
         let def_map = DefMap::empty(
             krate,
             Arc::new(DefMapCrateData::new(edition)),
-            ModuleData::new(module_origin, Visibility::Public),
+            ModuleData::new(module_origin, Visibility::Public, false),
             None,
         );
         do_collect_defs(&db, def_map)