Auto merge of #17221 - Veykril:lazier-validation, r=Veykril

internal: Lazier macro parse tree validation

Author: bors

crates/base-db/src/lib.rs

@@ -8,7 +8,7 @@ mod input;
 use std::panic;
 
 use salsa::Durability;
-use syntax::{ast, Parse, SourceFile};
+use syntax::{ast, Parse, SourceFile, SyntaxError};
 use triomphe::Arc;
 
 pub use crate::{
@@ -62,6 +62,9 @@ pub trait SourceDatabase: FileLoader + std::fmt::Debug {
     /// Parses the file into the syntax tree.
     fn parse(&self, file_id: FileId) -> Parse<ast::SourceFile>;
 
+    /// Returns the set of errors obtained from parsing the file including validation errors.
+    fn parse_errors(&self, file_id: FileId) -> Option<Arc<[SyntaxError]>>;
+
     /// The crate graph.
     #[salsa::input]
     fn crate_graph(&self) -> Arc<CrateGraph>;
@@ -88,6 +91,14 @@ fn parse(db: &dyn SourceDatabase, file_id: FileId) -> Parse<ast::SourceFile> {
     SourceFile::parse(&text, span::Edition::CURRENT)
 }
 
+fn parse_errors(db: &dyn SourceDatabase, file_id: FileId) -> Option<Arc<[SyntaxError]>> {
+    let errors = db.parse(file_id).errors();
+    match &*errors {
+        [] => None,
+        [..] => Some(errors.into()),
+    }
+}
+
 /// We don't want to give HIR knowledge of source roots, hence we extract these
 /// methods into a separate DB.
 #[salsa::query_group(SourceDatabaseExtStorage)]

crates/hir-def/src/body.rs

@@ -10,9 +10,10 @@ use std::ops::Index;
 
 use base_db::CrateId;
 use cfg::{CfgExpr, CfgOptions};
-use hir_expand::{name::Name, HirFileId, InFile};
+use hir_expand::{name::Name, InFile};
 use la_arena::{Arena, ArenaMap};
 use rustc_hash::FxHashMap;
+use span::MacroFileId;
 use syntax::{ast, AstPtr, SyntaxNodePtr};
 use triomphe::Arc;
 
@@ -98,7 +99,7 @@ pub struct BodySourceMap {
 
     format_args_template_map: FxHashMap<ExprId, Vec<(syntax::TextRange, Name)>>,
 
-    expansions: FxHashMap<InFile<AstPtr<ast::MacroCall>>, HirFileId>,
+    expansions: FxHashMap<InFile<AstPtr<ast::MacroCall>>, MacroFileId>,
 
     /// Diagnostics accumulated during body lowering. These contain `AstPtr`s and so are stored in
     /// the source map (since they're just as volatile).
@@ -349,11 +350,17 @@ impl BodySourceMap {
         self.expr_map.get(&src).cloned()
     }
 
-    pub fn node_macro_file(&self, node: InFile<&ast::MacroCall>) -> Option<HirFileId> {
+    pub fn node_macro_file(&self, node: InFile<&ast::MacroCall>) -> Option<MacroFileId> {
         let src = node.map(AstPtr::new);
         self.expansions.get(&src).cloned()
     }
 
+    pub fn macro_calls(
+        &self,
+    ) -> impl Iterator<Item = (InFile<AstPtr<ast::MacroCall>>, MacroFileId)> + '_ {
+        self.expansions.iter().map(|(&a, &b)| (a, b))
+    }
+
     pub fn pat_syntax(&self, pat: PatId) -> Result<PatSource, SyntheticSyntax> {
         self.pat_map_back.get(pat).cloned().ok_or(SyntheticSyntax)
     }

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

@@ -1006,7 +1006,9 @@ impl ExprCollector<'_> {
             Some((mark, expansion)) => {
                 // Keep collecting even with expansion errors so we can provide completions and
                 // other services in incomplete macro expressions.
-                self.source_map.expansions.insert(macro_call_ptr, self.expander.current_file_id());
+                self.source_map
+                    .expansions
+                    .insert(macro_call_ptr, self.expander.current_file_id().macro_file().unwrap());
                 let prev_ast_id_map = mem::replace(
                     &mut self.ast_id_map,
                     self.db.ast_id_map(self.expander.current_file_id()),

crates/hir-def/src/data.rs

@@ -229,7 +229,7 @@ pub struct TraitData {
     /// method calls to this trait's methods when the receiver is an array and the crate edition is
     /// 2015 or 2018.
     // box it as the vec is usually empty anyways
-    pub attribute_calls: Option<Box<Vec<(AstId<ast::Item>, MacroCallId)>>>,
+    pub macro_calls: Option<Box<Vec<(AstId<ast::Item>, MacroCallId)>>>,
 }
 
 impl TraitData {
@@ -258,12 +258,12 @@ impl TraitData {
         let mut collector =
             AssocItemCollector::new(db, module_id, tree_id.file_id(), ItemContainerId::TraitId(tr));
         collector.collect(&item_tree, tree_id.tree_id(), &tr_def.items);
-        let (items, attribute_calls, diagnostics) = collector.finish();
+        let (items, macro_calls, diagnostics) = collector.finish();
 
         (
             Arc::new(TraitData {
                 name,
-                attribute_calls,
+                macro_calls,
                 items,
                 is_auto,
                 is_unsafe,
@@ -298,7 +298,7 @@ impl TraitData {
     }
 
     pub fn attribute_calls(&self) -> impl Iterator<Item = (AstId<ast::Item>, MacroCallId)> + '_ {
-        self.attribute_calls.iter().flat_map(|it| it.iter()).copied()
+        self.macro_calls.iter().flat_map(|it| it.iter()).copied()
     }
 }
 
@@ -319,15 +319,15 @@ impl TraitAliasData {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq)]
 pub struct ImplData {
     pub target_trait: Option<Interned<TraitRef>>,
     pub self_ty: Interned<TypeRef>,
     pub items: Vec<AssocItemId>,
     pub is_negative: bool,
     pub is_unsafe: bool,
     // box it as the vec is usually empty anyways
-    pub attribute_calls: Option<Box<Vec<(AstId<ast::Item>, MacroCallId)>>>,
+    pub macro_calls: Option<Box<Vec<(AstId<ast::Item>, MacroCallId)>>>,
 }
 
 impl ImplData {
@@ -354,7 +354,7 @@ impl ImplData {
             AssocItemCollector::new(db, module_id, tree_id.file_id(), ItemContainerId::ImplId(id));
         collector.collect(&item_tree, tree_id.tree_id(), &impl_def.items);
 
-        let (items, attribute_calls, diagnostics) = collector.finish();
+        let (items, macro_calls, diagnostics) = collector.finish();
         let items = items.into_iter().map(|(_, item)| item).collect();
 
         (
@@ -364,14 +364,14 @@ impl ImplData {
                 items,
                 is_negative,
                 is_unsafe,
-                attribute_calls,
+                macro_calls,
             }),
             DefDiagnostics::new(diagnostics),
         )
     }
 
     pub fn attribute_calls(&self) -> impl Iterator<Item = (AstId<ast::Item>, MacroCallId)> + '_ {
-        self.attribute_calls.iter().flat_map(|it| it.iter()).copied()
+        self.macro_calls.iter().flat_map(|it| it.iter()).copied()
     }
 }
 
@@ -573,7 +573,7 @@ struct AssocItemCollector<'a> {
     expander: Expander,
 
     items: Vec<(Name, AssocItemId)>,
-    attr_calls: Vec<(AstId<ast::Item>, MacroCallId)>,
+    macro_calls: Vec<(AstId<ast::Item>, MacroCallId)>,
 }
 
 impl<'a> AssocItemCollector<'a> {
@@ -590,7 +590,7 @@ impl<'a> AssocItemCollector<'a> {
             container,
             expander: Expander::new(db, file_id, module_id),
             items: Vec::new(),
-            attr_calls: Vec::new(),
+            macro_calls: Vec::new(),
             diagnostics: Vec::new(),
         }
     }
@@ -604,7 +604,7 @@ impl<'a> AssocItemCollector<'a> {
     ) {
         (
             self.items,
-            if self.attr_calls.is_empty() { None } else { Some(Box::new(self.attr_calls)) },
+            if self.macro_calls.is_empty() { None } else { Some(Box::new(self.macro_calls)) },
             self.diagnostics,
         )
     }
@@ -662,11 +662,11 @@ impl<'a> AssocItemCollector<'a> {
                             }
                         }
 
-                        self.attr_calls.push((ast_id, call_id));
+                        self.macro_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());
+                        self.collect_macro_items(res);
                         continue 'items;
                     }
                     Ok(_) => (),
@@ -743,11 +743,8 @@ impl<'a> AssocItemCollector<'a> {
                     Ok(Some(call_id)) => {
                         let res =
                             self.expander.enter_expand_id::<ast::MacroItems>(self.db, call_id);
-                        self.collect_macro_items(res, &|| hir_expand::MacroCallKind::FnLike {
-                            ast_id: InFile::new(file_id, ast_id),
-                            expand_to: hir_expand::ExpandTo::Items,
-                            eager: None,
-                        });
+                        self.macro_calls.push((InFile::new(file_id, ast_id.upcast()), call_id));
+                        self.collect_macro_items(res);
                     }
                     Ok(None) => (),
                     Err(_) => {
@@ -766,39 +763,8 @@ impl<'a> AssocItemCollector<'a> {
         }
     }
 
-    fn collect_macro_items(
-        &mut self,
-        ExpandResult { value, err }: ExpandResult<Option<(Mark, Parse<ast::MacroItems>)>>,
-        error_call_kind: &dyn Fn() -> hir_expand::MacroCallKind,
-    ) {
-        let Some((mark, parse)) = value else { return };
-
-        if let Some(err) = err {
-            let diag = match err {
-                // why is this reported here?
-                hir_expand::ExpandError::UnresolvedProcMacro(krate) => {
-                    DefDiagnostic::unresolved_proc_macro(
-                        self.module_id.local_id,
-                        error_call_kind(),
-                        krate,
-                    )
-                }
-                _ => DefDiagnostic::macro_error(
-                    self.module_id.local_id,
-                    error_call_kind(),
-                    err.to_string(),
-                ),
-            };
-            self.diagnostics.push(diag);
-        }
-        let errors = parse.errors();
-        if !errors.is_empty() {
-            self.diagnostics.push(DefDiagnostic::macro_expansion_parse_error(
-                self.module_id.local_id,
-                error_call_kind(),
-                errors.into_boxed_slice(),
-            ));
-        }
+    fn collect_macro_items(&mut self, res: ExpandResult<Option<(Mark, Parse<ast::MacroItems>)>>) {
+        let Some((mark, _parse)) = res.value else { return };
 
         let tree_id = item_tree::TreeId::new(self.expander.current_file_id(), None);
         let item_tree = tree_id.item_tree(self.db);

crates/hir-def/src/item_scope.rs

@@ -234,6 +234,14 @@ impl ItemScope {
         self.impls.iter().copied()
     }
 
+    pub fn all_macro_calls(&self) -> impl Iterator<Item = MacroCallId> + '_ {
+        self.macro_invocations.values().copied().chain(self.attr_macros.values().copied()).chain(
+            self.derive_macros.values().flat_map(|it| {
+                it.iter().flat_map(|it| it.derive_call_ids.iter().copied().flatten())
+            }),
+        )
+    }
+
     pub(crate) fn modules_in_scope(&self) -> impl Iterator<Item = (ModuleId, Visibility)> + '_ {
         self.types.values().copied().filter_map(|(def, vis, _)| match def {
             ModuleDefId::ModuleId(module) => Some((module, vis)),

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

@@ -15,15 +15,13 @@ use hir_expand::{
     builtin_fn_macro::find_builtin_macro,
     name::{name, AsName, Name},
     proc_macro::CustomProcMacroExpander,
-    ExpandResult, ExpandTo, HirFileId, InFile, MacroCallId, MacroCallKind, MacroCallLoc,
-    MacroDefId, MacroDefKind,
+    ExpandTo, HirFileId, InFile, MacroCallId, MacroCallKind, MacroDefId, MacroDefKind,
 };
 use itertools::{izip, Itertools};
 use la_arena::Idx;
 use limit::Limit;
 use rustc_hash::{FxHashMap, FxHashSet};
 use span::{Edition, ErasedFileAstId, FileAstId, Span, SyntaxContextId};
-use stdx::always;
 use syntax::ast;
 use triomphe::Arc;
 
@@ -1412,31 +1410,6 @@ impl DefCollector<'_> {
         }
         let file_id = macro_call_id.as_file();
 
-        // First, fetch the raw expansion result for purposes of error reporting. This goes through
-        // `parse_macro_expansion_error` to avoid depending on the full expansion result (to improve
-        // incrementality).
-        // FIXME: This kind of error fetching feels a bit odd?
-        let ExpandResult { value: errors, err } =
-            self.db.parse_macro_expansion_error(macro_call_id);
-        if let Some(err) = err {
-            let loc: MacroCallLoc = self.db.lookup_intern_macro_call(macro_call_id);
-            let diag = match err {
-                // why is this reported here?
-                hir_expand::ExpandError::UnresolvedProcMacro(krate) => {
-                    always!(krate == loc.def.krate);
-                    DefDiagnostic::unresolved_proc_macro(module_id, loc.kind.clone(), loc.def.krate)
-                }
-                _ => DefDiagnostic::macro_error(module_id, loc.kind, err.to_string()),
-            };
-
-            self.def_map.diagnostics.push(diag);
-        }
-        if !errors.is_empty() {
-            let loc: MacroCallLoc = self.db.lookup_intern_macro_call(macro_call_id);
-            let diag = DefDiagnostic::macro_expansion_parse_error(module_id, loc.kind, errors);
-            self.def_map.diagnostics.push(diag);
-        }
-
         // Then, fetch and process the item tree. This will reuse the expansion result from above.
         let item_tree = self.db.file_item_tree(file_id);
 

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

@@ -6,7 +6,7 @@ use base_db::CrateId;
 use cfg::{CfgExpr, CfgOptions};
 use hir_expand::{attrs::AttrId, ErasedAstId, MacroCallKind};
 use la_arena::Idx;
-use syntax::{ast, SyntaxError};
+use syntax::ast;
 
 use crate::{
     item_tree::{self, ItemTreeId},
@@ -23,8 +23,6 @@ pub enum DefDiagnosticKind {
     UnconfiguredCode { ast: ErasedAstId, cfg: CfgExpr, opts: CfgOptions },
     UnresolvedProcMacro { ast: MacroCallKind, krate: CrateId },
     UnresolvedMacroCall { ast: MacroCallKind, path: ModPath },
-    MacroError { ast: MacroCallKind, message: String },
-    MacroExpansionParseError { ast: MacroCallKind, errors: Box<[SyntaxError]> },
     UnimplementedBuiltinMacro { ast: AstId<ast::Macro> },
     InvalidDeriveTarget { ast: AstId<ast::Item>, id: usize },
     MalformedDerive { ast: AstId<ast::Adt>, id: usize },
@@ -98,33 +96,14 @@ impl DefDiagnostic {
     // FIXME: This is used for a lot of things, unresolved proc macros, disabled proc macros, etc
     // yet the diagnostic handler in ide-diagnostics has to figure out what happened because this
     // struct loses all that information!
-    pub(crate) fn unresolved_proc_macro(
+    pub fn unresolved_proc_macro(
         container: LocalModuleId,
         ast: MacroCallKind,
         krate: CrateId,
     ) -> Self {
         Self { in_module: container, kind: DefDiagnosticKind::UnresolvedProcMacro { ast, krate } }
     }
 
-    pub(crate) fn macro_error(
-        container: LocalModuleId,
-        ast: MacroCallKind,
-        message: String,
-    ) -> Self {
-        Self { in_module: container, kind: DefDiagnosticKind::MacroError { ast, message } }
-    }
-
-    pub(crate) fn macro_expansion_parse_error(
-        container: LocalModuleId,
-        ast: MacroCallKind,
-        errors: Box<[SyntaxError]>,
-    ) -> Self {
-        Self {
-            in_module: container,
-            kind: DefDiagnosticKind::MacroExpansionParseError { ast, errors },
-        }
-    }
-
     // FIXME: Whats the difference between this and unresolved_proc_macro
     pub(crate) fn unresolved_macro_call(
         container: LocalModuleId,