Re-enable proc-macros

Author: Veykril

Cargo.lock

@@ -543,6 +543,9 @@ impl ProcMacroExpander for IdentityProcMacroExpander {
         subtree: &Subtree<SpanData>,
         _: Option<&Subtree<SpanData>>,
         _: &Env,
+        _: SpanData,
+        _: SpanData,
+        _: SpanData,
     ) -> Result<Subtree<SpanData>, ProcMacroExpansionError> {
         Ok(subtree.clone())
     }
@@ -557,6 +560,9 @@ impl ProcMacroExpander for AttributeInputReplaceProcMacroExpander {
         _: &Subtree<SpanData>,
         attrs: Option<&Subtree<SpanData>>,
         _: &Env,
+        _: SpanData,
+        _: SpanData,
+        _: SpanData,
     ) -> Result<Subtree<SpanData>, ProcMacroExpansionError> {
         attrs
             .cloned()
@@ -572,6 +578,9 @@ impl ProcMacroExpander for MirrorProcMacroExpander {
         input: &Subtree<SpanData>,
         _: Option<&Subtree<SpanData>>,
         _: &Env,
+        _: SpanData,
+        _: SpanData,
+        _: SpanData,
     ) -> Result<Subtree<SpanData>, ProcMacroExpansionError> {
         fn traverse(input: &Subtree<SpanData>) -> Subtree<SpanData> {
             let mut token_trees = vec![];
@@ -599,6 +608,9 @@ impl ProcMacroExpander for ShortenProcMacroExpander {
         input: &Subtree<SpanData>,
         _: Option<&Subtree<SpanData>>,
         _: &Env,
+        _: SpanData,
+        _: SpanData,
+        _: SpanData,
     ) -> Result<Subtree<SpanData>, ProcMacroExpansionError> {
         return Ok(traverse(input));
 

crates/base-db/src/fixture.rs

@@ -262,6 +262,9 @@ pub trait ProcMacroExpander: fmt::Debug + Send + Sync + RefUnwindSafe {
         subtree: &tt::Subtree<SpanData>,
         attrs: Option<&tt::Subtree<SpanData>>,
         env: &Env,
+        def_site: SpanData,
+        call_site: SpanData,
+        mixed_site: SpanData,
     ) -> Result<tt::Subtree<SpanData>, ProcMacroExpansionError>;
 }
 

crates/base-db/src/input.rs

@@ -38,6 +38,8 @@ impl SyntaxContextId {
     // currently (which kind of makes sense but we need it here!)
     pub const SELF_REF: Self =
         SyntaxContextId(unsafe { InternId::new_unchecked(InternId::MAX - 1) });
+    /// Used syntax fixups
+    pub const FAKE: Self = SyntaxContextId(unsafe { InternId::new_unchecked(InternId::MAX - 2) });
 
     pub fn is_root(self) -> bool {
         self == Self::ROOT

crates/base-db/src/span.rs

@@ -16,7 +16,7 @@ mod proc_macros;
 
 use std::{iter, ops::Range, sync};
 
-use base_db::{fixture::WithFixture, ProcMacro, SourceDatabase};
+use base_db::{fixture::WithFixture, span::SpanData, ProcMacro, SourceDatabase};
 use expect_test::Expect;
 use hir_expand::{db::ExpandDatabase, span::SpanMapRef, HirFileIdExt, InFile, MacroFileId};
 use stdx::format_to;
@@ -307,6 +307,9 @@ impl base_db::ProcMacroExpander for IdentityWhenValidProcMacroExpander {
         subtree: &Subtree,
         _: Option<&Subtree>,
         _: &base_db::Env,
+        _: SpanData,
+        _: SpanData,
+        _: SpanData,
     ) -> Result<Subtree, base_db::ProcMacroExpansionError> {
         let (parse, _) =
             ::mbe::token_tree_to_syntax_node(subtree, ::mbe::TopEntryPoint::MacroItems);

crates/hir-def/src/macro_expansion_tests/mod.rs

@@ -233,7 +233,17 @@ pub fn expand_speculative(
     let speculative_expansion = match loc.def.kind {
         MacroDefKind::ProcMacro(expander, ..) => {
             tt.delimiter = tt::Delimiter::UNSPECIFIED;
-            expander.expand(db, loc.def.krate, loc.krate, &tt, attr_arg.as_ref())
+            let call_site = loc.span(db);
+            expander.expand(
+                db,
+                loc.def.krate,
+                loc.krate,
+                &tt,
+                attr_arg.as_ref(),
+                call_site,
+                call_site,
+                call_site,
+            )
         }
         MacroDefKind::BuiltInAttr(BuiltinAttrExpander::Derive, _) => {
             pseudo_derive_attr_expansion(&tt, attr_arg.as_ref()?)
@@ -398,17 +408,23 @@ fn macro_arg(
             MacroCallKind::Attr { ast_id, .. } => ast_id.to_ptr(db).to_node(&root).syntax().clone(),
         };
         let censor = censor_for_macro_input(&loc, &syntax);
-        // let mut fixups = fixup::fixup_syntax(&node);
-        // fixups.replace.extend(censor.into_iter().map(|node| (node.into(), Vec::new())));
-        // let (mut tt, tmap, _) = mbe::syntax_node_to_token_tree_with_modifications(
-        //     &node,
-        //     fixups.token_map,
-        //     fixups.next_id,
-        //     fixups.replace,
-        //     fixups.append,
-        // );
-
-        let mut tt = mbe::syntax_node_to_token_tree_censored(&syntax, map.as_ref(), censor);
+        let mut tt = match loc.kind {
+            MacroCallKind::FnLike { .. } => {
+                mbe::syntax_node_to_token_tree_censored(&syntax, map.as_ref(), censor)
+            }
+            MacroCallKind::Derive { .. } | MacroCallKind::Attr { .. } => {
+                // let mut fixups = crate::fixup::fixup_syntax(&syntax);
+                // fixups.replace.extend(censor.into_iter().map(|node| (node.into(), Vec::new())));
+                // let (mut tt, tmap, _) = mbe::syntax_node_to_token_tree_with_modifications(
+                //     &node,
+                //     fixups.token_map,
+                //     fixups.next_id,
+                //     fixups.replace,
+                //     fixups.append,
+                // );
+                mbe::syntax_node_to_token_tree_censored(&syntax, map.as_ref(), censor)
+            }
+        };
 
         if loc.def.is_proc_macro() {
             // proc macros expect their inputs without parentheses, MBEs expect it with them included
@@ -658,8 +674,19 @@ fn expand_proc_macro(db: &dyn ExpandDatabase, id: MacroCallId) -> ExpandResult<A
         _ => None,
     };
 
-    let ExpandResult { value: tt, err } =
-        expander.expand(db, loc.def.krate, loc.krate, &macro_arg, attr_arg);
+    let call_site = loc.span(db);
+    let ExpandResult { value: tt, err } = expander.expand(
+        db,
+        loc.def.krate,
+        loc.krate,
+        &macro_arg,
+        attr_arg,
+        // FIXME
+        call_site,
+        call_site,
+        // FIXME
+        call_site,
+    );
 
     // Set a hard limit for the expanded tt
     if let Err(value) = check_tt_count(&tt) {