feat: ignored and disabled macro expansion

Author: tamasfe

crates/base-db/src/input.rs

@@ -255,6 +255,16 @@ pub trait ProcMacroExpander: fmt::Debug + Send + Sync + RefUnwindSafe {
         attrs: Option<&Subtree>,
         env: &Env,
     ) -> Result<Subtree, ProcMacroExpansionError>;
+
+    /// If this returns `false`, expansions via [`expand`](ProcMacroExpander::expand) will always
+    /// return the input subtree or will always return an error.
+    ///
+    /// This is used to skip any additional expansion-related work,
+    /// e.g. to make sure we do not touch the syntax tree in any way
+    /// if a proc macro will never be expanded.
+    fn should_expand(&self) -> bool {
+        true
+    }
 }
 
 pub enum ProcMacroExpansionError {

crates/hir-def/src/data.rs

@@ -618,7 +618,6 @@ impl<'a> AssocItemCollector<'a> {
                     attr,
                 ) {
                     Ok(ResolvedAttr::Macro(call_id)) => {
-                        self.attr_calls.push((ast_id, call_id));
                         // If proc attribute macro expansion is disabled, skip expanding it here
                         if !self.db.expand_proc_attr_macros() {
                             continue 'attrs;
@@ -631,10 +630,20 @@ impl<'a> AssocItemCollector<'a> {
                             // disabled. This is analogous to the handling in
                             // `DefCollector::collect_macros`.
                             if exp.is_dummy() {
+                                self.diagnostics.push(DefDiagnostic::unresolved_proc_macro(
+                                    self.module_id.local_id,
+                                    loc.kind,
+                                    loc.def.krate,
+                                ));
+
+                                continue 'attrs;
+                            } else if exp.is_disabled() {
                                 continue 'attrs;
                             }
                         }
 
+                        self.attr_calls.push((ast_id, call_id));
+
                         let res =
                             self.expander.enter_expand_id::<ast::MacroItems>(self.db, call_id);
                         self.collect_macro_items(res, &|| loc.kind.clone());

crates/hir-def/src/nameres/collector.rs

@@ -87,7 +87,15 @@ pub(super) fn collect_defs(db: &dyn DefDatabase, def_map: DefMap, tree_id: TreeI
                         // FIXME: a hacky way to create a Name from string.
                         let name =
                             tt::Ident { text: it.name.clone(), span: tt::TokenId::unspecified() };
-                        (name.as_name(), ProcMacroExpander::new(base_db::ProcMacroId(idx as u32)))
+
+                        (
+                            name.as_name(),
+                            if it.expander.should_expand() {
+                                ProcMacroExpander::new(base_db::ProcMacroId(idx as u32))
+                            } else {
+                                ProcMacroExpander::disabled()
+                            },
+                        )
                     })
                     .collect())
             }
@@ -1122,6 +1130,27 @@ impl DefCollector<'_> {
                         resolver_def_id,
                     );
                     if let Ok(Some(call_id)) = call_id {
+                        let loc: MacroCallLoc = self.db.lookup_intern_macro_call(call_id);
+
+                        if let MacroDefKind::ProcMacro(expander, _, _) = loc.def.kind {
+                            if expander.is_dummy() || expander.is_disabled() {
+                                // If there's no expander for the proc macro (e.g.
+                                // because proc macros are disabled, or building the
+                                // proc macro crate failed), report this and skip
+                                // expansion like we would if it was disabled
+                                self.def_map.diagnostics.push(
+                                    DefDiagnostic::unresolved_proc_macro(
+                                        directive.module_id,
+                                        loc.kind,
+                                        loc.def.krate,
+                                    ),
+                                );
+
+                                res = ReachedFixedPoint::No;
+                                return false;
+                            }
+                        }
+
                         push_resolved(directive, call_id);
 
                         res = ReachedFixedPoint::No;
@@ -1322,6 +1351,8 @@ impl DefCollector<'_> {
                                 loc.def.krate,
                             ));
 
+                            return recollect_without(self);
+                        } else if exp.is_disabled() {
                             return recollect_without(self);
                         }
                     }
@@ -2238,8 +2269,12 @@ impl ModCollector<'_, '_> {
     }
 
     fn import_all_legacy_macros(&mut self, module_id: LocalModuleId) {
-        let Some((source, target)) = Self::borrow_modules(self.def_collector.def_map.modules.as_mut(), module_id, self.module_id) else {
-            return
+        let Some((source, target)) = Self::borrow_modules(
+            self.def_collector.def_map.modules.as_mut(),
+            module_id,
+            self.module_id,
+        ) else {
+            return;
         };
 
         for (name, macs) in source.scope.legacy_macros() {

crates/hir-expand/src/lib.rs

@@ -56,6 +56,8 @@ pub type ExpandResult<T> = ValueResult<T, ExpandError>;
 #[derive(Debug, PartialEq, Eq, Clone, Hash)]
 pub enum ExpandError {
     UnresolvedProcMacro(CrateId),
+    /// The macro expansion is disabled.
+    MacroDisabled,
     Mbe(mbe::ExpandError),
     RecursionOverflowPoisoned,
     Other(Box<Box<str>>),
@@ -82,6 +84,7 @@ impl fmt::Display for ExpandError {
                 f.write_str("overflow expanding the original macro")
             }
             ExpandError::Other(it) => f.write_str(it),
+            ExpandError::MacroDisabled => f.write_str("macro disabled"),
         }
     }
 }

crates/hir-expand/src/proc_macro.rs

@@ -11,6 +11,7 @@ pub struct ProcMacroExpander {
 }
 
 const DUMMY_ID: u32 = !0;
+const DISABLED_ID: u32 = !1;
 
 impl ProcMacroExpander {
     pub fn new(proc_macro_id: ProcMacroId) -> Self {
@@ -22,10 +23,20 @@ impl ProcMacroExpander {
         Self { proc_macro_id: ProcMacroId(DUMMY_ID) }
     }
 
+    /// The macro was not yet resolved.
     pub fn is_dummy(&self) -> bool {
         self.proc_macro_id.0 == DUMMY_ID
     }
 
+    pub fn disabled() -> Self {
+        Self { proc_macro_id: ProcMacroId(DISABLED_ID) }
+    }
+
+    /// The macro is explicitly disabled and cannot be expanded.
+    pub fn is_disabled(&self) -> bool {
+        self.proc_macro_id.0 == DISABLED_ID
+    }
+
     pub fn expand(
         self,
         db: &dyn ExpandDatabase,
@@ -38,6 +49,9 @@ impl ProcMacroExpander {
             ProcMacroId(DUMMY_ID) => {
                 ExpandResult::new(tt::Subtree::empty(), ExpandError::UnresolvedProcMacro(def_crate))
             }
+            ProcMacroId(DISABLED_ID) => {
+                ExpandResult::new(tt::Subtree::empty(), ExpandError::MacroDisabled)
+            }
             ProcMacroId(id) => {
                 let proc_macros = db.proc_macros();
                 let proc_macros = match proc_macros.get(&def_crate) {

crates/rust-analyzer/src/config.rs

@@ -1133,7 +1133,7 @@ impl Config {
         Some(AbsPathBuf::try_from(path).unwrap_or_else(|path| self.root_path.join(&path)))
     }
 
-    pub fn dummy_replacements(&self) -> &FxHashMap<Box<str>, Box<[Box<str>]>> {
+    pub fn ignored_proc_macros(&self) -> &FxHashMap<Box<str>, Box<[Box<str>]>> {
         &self.data.procMacro_ignored
     }
 

crates/rust-analyzer/src/reload.rs

@@ -281,13 +281,13 @@ impl GlobalState {
 
     pub(crate) fn fetch_proc_macros(&mut self, cause: Cause, paths: Vec<ProcMacroPaths>) {
         tracing::info!(%cause, "will load proc macros");
-        let dummy_replacements = self.config.dummy_replacements().clone();
+        let ignored_proc_macros = self.config.ignored_proc_macros().clone();
         let proc_macro_clients = self.proc_macro_clients.clone();
 
         self.task_pool.handle.spawn_with_sender(ThreadIntent::Worker, move |sender| {
             sender.send(Task::LoadProcMacros(ProcMacroProgress::Begin)).unwrap();
 
-            let dummy_replacements = &dummy_replacements;
+            let ignored_proc_macros = &ignored_proc_macros;
             let progress = {
                 let sender = sender.clone();
                 &move |msg| {
@@ -315,7 +315,13 @@ impl GlobalState {
                                         crate_name
                                             .as_deref()
                                             .and_then(|crate_name| {
-                                                dummy_replacements.get(crate_name).map(|v| &**v)
+                                                ignored_proc_macros.iter().find_map(|c| {
+                                                    if eq_ignore_underscore(&*c.0, crate_name) {
+                                                        Some(&**c.1)
+                                                    } else {
+                                                        None
+                                                    }
+                                                })
                                             })
                                             .unwrap_or_default(),
                                     )
@@ -340,7 +346,11 @@ impl GlobalState {
         let _p = profile::span("GlobalState::switch_workspaces");
         tracing::info!(%cause, "will switch workspaces");
 
-        let Some((workspaces, force_reload_crate_graph)) = self.fetch_workspaces_queue.last_op_result() else { return; };
+        let Some((workspaces, force_reload_crate_graph)) =
+            self.fetch_workspaces_queue.last_op_result()
+        else {
+            return;
+        };
 
         if let Err(_) = self.fetch_workspace_error() {
             if !self.workspaces.is_empty() {
@@ -531,7 +541,7 @@ impl GlobalState {
         let mut buf = String::new();
 
         let Some((last_op_result, _)) = self.fetch_workspaces_queue.last_op_result() else {
-            return Ok(())
+            return Ok(());
         };
         if last_op_result.is_empty() {
             stdx::format_to!(buf, "rust-analyzer failed to discover workspace");
@@ -762,12 +772,11 @@ impl SourceRootConfig {
     }
 }
 
-/// Load the proc-macros for the given lib path, replacing all expanders whose names are in `dummy_replace`
-/// with an identity dummy expander.
+/// Load the proc-macros for the given lib path, marking them as ignored if needed.
 pub(crate) fn load_proc_macro(
     server: &ProcMacroServer,
     path: &AbsPath,
-    dummy_replace: &[Box<str>],
+    ignored_macros: &[Box<str>],
 ) -> ProcMacroLoadResult {
     let res: Result<Vec<_>, String> = (|| {
         let dylib = MacroDylib::new(path.to_path_buf());
@@ -777,7 +786,7 @@ pub(crate) fn load_proc_macro(
         }
         Ok(vec
             .into_iter()
-            .map(|expander| expander_to_proc_macro(expander, dummy_replace))
+            .map(|expander| expander_to_proc_macro(expander, ignored_macros))
             .collect())
     })();
     return match res {
@@ -796,7 +805,7 @@ pub(crate) fn load_proc_macro(
 
     fn expander_to_proc_macro(
         expander: proc_macro_api::ProcMacro,
-        dummy_replace: &[Box<str>],
+        ignored_macros: &[Box<str>],
     ) -> ProcMacro {
         let name = SmolStr::from(expander.name());
         let kind = match expander.kind() {
@@ -805,7 +814,7 @@ pub(crate) fn load_proc_macro(
             proc_macro_api::ProcMacroKind::Attr => ProcMacroKind::Attr,
         };
         let expander: sync::Arc<dyn ProcMacroExpander> =
-            if dummy_replace.iter().any(|replace| &**replace == name) {
+            if ignored_macros.iter().any(|replace| &**replace == name) {
                 match kind {
                     ProcMacroKind::Attr => sync::Arc::new(IdentityExpander),
                     _ => sync::Arc::new(EmptyExpander),
@@ -848,6 +857,10 @@ pub(crate) fn load_proc_macro(
         ) -> Result<tt::Subtree, ProcMacroExpansionError> {
             Ok(subtree.clone())
         }
+
+        fn should_expand(&self) -> bool {
+            false
+        }
     }
 
     /// Empty expander, used for proc-macros that are deliberately ignored by the user.
@@ -863,6 +876,10 @@ pub(crate) fn load_proc_macro(
         ) -> Result<tt::Subtree, ProcMacroExpansionError> {
             Ok(tt::Subtree::empty())
         }
+
+        fn should_expand(&self) -> bool {
+            false
+        }
     }
 }
 
@@ -910,3 +927,18 @@ pub(crate) fn should_refresh_for_change(path: &AbsPath, change_kind: ChangeKind)
     }
     false
 }
+
+/// Similar to [`str::eq_ignore_ascii_case`] but instead of ignoring
+/// case, we say that `-` and `_` are equal.
+fn eq_ignore_underscore(s1: &str, s2: &str) -> bool {
+    if s1.len() != s2.len() {
+        return false;
+    }
+
+    s1.as_bytes().iter().zip(s2.as_bytes()).all(|(c1, c2)| {
+        let c1_underscore = c1 == &b'_' || c1 == &b'-';
+        let c2_underscore = c2 == &b'_' || c2 == &b'-';
+
+        c1 == c2 || (c1_underscore && c2_underscore)
+    })
+}