fix: Report proc macro errors in expressions correctly as well

crates/hir-def/src/body.rs

@@ -312,7 +312,7 @@ pub struct SyntheticSyntax;
 pub enum BodyDiagnostic {
     InactiveCode { node: InFile<SyntaxNodePtr>, cfg: CfgExpr, opts: CfgOptions },
     MacroError { node: InFile<AstPtr<ast::MacroCall>>, message: String },
-    UnresolvedProcMacro { node: InFile<AstPtr<ast::MacroCall>> },
+    UnresolvedProcMacro { node: InFile<AstPtr<ast::MacroCall>>, krate: CrateId },
     UnresolvedMacroCall { node: InFile<AstPtr<ast::MacroCall>>, path: ModPath },
 }
 

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

@@ -572,9 +572,10 @@ impl ExprCollector<'_> {
 
         if record_diagnostics {
             match &res.err {
-                Some(ExpandError::UnresolvedProcMacro) => {
+                Some(ExpandError::UnresolvedProcMacro(krate)) => {
                     self.source_map.diagnostics.push(BodyDiagnostic::UnresolvedProcMacro {
                         node: InFile::new(outer_file, syntax_ptr),
+                        krate: *krate,
                     });
                 }
                 Some(err) => {

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

@@ -22,6 +22,7 @@ use itertools::Itertools;
 use la_arena::Idx;
 use limit::Limit;
 use rustc_hash::{FxHashMap, FxHashSet};
+use stdx::always;
 use syntax::{ast, SmolStr};
 
 use crate::{
@@ -1234,7 +1235,7 @@ impl DefCollector<'_> {
                         self.def_map.diagnostics.push(DefDiagnostic::unresolved_proc_macro(
                             directive.module_id,
                             loc.kind,
-                            Some(loc.def.krate),
+                            loc.def.krate,
                         ));
                         return recollect_without(self);
                     }
@@ -1258,7 +1259,7 @@ impl DefCollector<'_> {
                             self.def_map.diagnostics.push(DefDiagnostic::unresolved_proc_macro(
                                 directive.module_id,
                                 loc.kind,
-                                Some(loc.def.krate),
+                                loc.def.krate,
                             ));
 
                             return recollect_without(self);
@@ -1308,13 +1309,10 @@ impl DefCollector<'_> {
         let err = self.db.macro_expand_error(macro_call_id);
         if let Some(err) = err {
             let diag = match err {
-                hir_expand::ExpandError::UnresolvedProcMacro => {
+                hir_expand::ExpandError::UnresolvedProcMacro(krate) => {
+                    always!(krate == loc.def.krate);
                     // Missing proc macros are non-fatal, so they are handled specially.
-                    DefDiagnostic::unresolved_proc_macro(
-                        module_id,
-                        loc.kind.clone(),
-                        Some(loc.def.krate),
-                    )
+                    DefDiagnostic::unresolved_proc_macro(module_id, loc.kind.clone(), loc.def.krate)
                 }
                 _ => DefDiagnostic::macro_error(module_id, loc.kind.clone(), err.to_string()),
             };

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

@@ -24,7 +24,7 @@ pub enum DefDiagnosticKind {
 
     UnconfiguredCode { ast: AstId<ast::Item>, cfg: CfgExpr, opts: CfgOptions },
 
-    UnresolvedProcMacro { ast: MacroCallKind, krate: Option<CrateId> },
+    UnresolvedProcMacro { ast: MacroCallKind, krate: CrateId },
 
     UnresolvedMacroCall { ast: MacroCallKind, path: ModPath },
 
@@ -85,7 +85,7 @@ impl DefDiagnostic {
     pub(super) fn unresolved_proc_macro(
         container: LocalModuleId,
         ast: MacroCallKind,
-        krate: Option<CrateId>,
+        krate: CrateId,
     ) -> Self {
         Self { in_module: container, kind: DefDiagnosticKind::UnresolvedProcMacro { ast, krate } }
     }

crates/hir-expand/src/lib.rs

@@ -43,7 +43,7 @@ pub type ExpandResult<T> = ValueResult<T, ExpandError>;
 
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub enum ExpandError {
-    UnresolvedProcMacro,
+    UnresolvedProcMacro(CrateId),
     Mbe(mbe::ExpandError),
     Other(Box<str>),
 }
@@ -57,7 +57,7 @@ impl From<mbe::ExpandError> for ExpandError {
 impl fmt::Display for ExpandError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            ExpandError::UnresolvedProcMacro => f.write_str("unresolved proc-macro"),
+            ExpandError::UnresolvedProcMacro(_) => f.write_str("unresolved proc-macro"),
             ExpandError::Mbe(it) => it.fmt(f),
             ExpandError::Other(it) => f.write_str(it),
         }

crates/hir-expand/src/proc_macro.rs

@@ -75,7 +75,7 @@ impl ProcMacroExpander {
                     },
                 }
             }
-            None => ExpandResult::only_err(ExpandError::UnresolvedProcMacro),
+            None => ExpandResult::only_err(ExpandError::UnresolvedProcMacro(self.krate)),
         }
     }
 }

crates/hir/src/diagnostics.rs

@@ -90,7 +90,7 @@ pub struct UnresolvedProcMacro {
     pub macro_name: Option<String>,
     pub kind: MacroKind,
     /// The crate id of the proc-macro this macro belongs to, or `None` if the proc-macro can't be found.
-    pub krate: Option<CrateId>,
+    pub krate: CrateId,
 }
 
 #[derive(Debug, Clone, Eq, PartialEq)]

crates/hir/src/lib.rs

@@ -1159,13 +1159,13 @@ impl DefWithBody {
                     }
                     .into(),
                 ),
-                BodyDiagnostic::UnresolvedProcMacro { node } => acc.push(
+                BodyDiagnostic::UnresolvedProcMacro { node, krate } => acc.push(
                     UnresolvedProcMacro {
                         node: node.clone().map(|it| it.into()),
                         precise_location: None,
                         macro_name: None,
                         kind: MacroKind::ProcMacro,
-                        krate: None,
+                        krate: *krate,
                     }
                     .into(),
                 ),

crates/ide-diagnostics/src/handlers/unresolved_proc_macro.rs

@@ -32,13 +32,13 @@ pub(crate) fn unresolved_proc_macro(
         None => "proc macro not expanded".to_string(),
     };
     let severity = if config_enabled { Severity::Error } else { Severity::WeakWarning };
-    let def_map = d.krate.map(|krate| ctx.sema.db.crate_def_map(krate));
+    let def_map = ctx.sema.db.crate_def_map(d.krate);
     let message = format!(
         "{message}: {}",
         if config_enabled {
-            match def_map.as_ref().and_then(|def_map| def_map.proc_macro_loading_error()) {
+            match def_map.proc_macro_loading_error() {
                 Some(e) => e,
-                None => "proc macro not found",
+                None => "proc macro not found in the built dylib",
             }
         } else {
             match d.kind {