Auto merge of #144385 - xizheyin:macro-hygiene, r=<try>

Optimize performance in macro hygiene system

Author: rust-bors[bot]

compiler/rustc_span/src/hygiene.rs

@@ -322,6 +322,7 @@ impl ExpnId {
 
     /// `expn_id.outer_expn_is_descendant_of(ctxt)` is equivalent to but faster than
     /// `expn_id.is_descendant_of(ctxt.outer_expn())`.
+    #[inline]
     pub fn outer_expn_is_descendant_of(self, ctxt: SyntaxContext) -> bool {
         HygieneData::with(|data| data.is_descendant_of(self, data.outer_expn(ctxt)))
     }
@@ -437,23 +438,28 @@ impl HygieneData {
         }
     }
 
+    #[inline]
     fn normalize_to_macros_2_0(&self, ctxt: SyntaxContext) -> SyntaxContext {
         self.syntax_context_data[ctxt.0 as usize].opaque
     }
 
+    #[inline]
     fn normalize_to_macro_rules(&self, ctxt: SyntaxContext) -> SyntaxContext {
         self.syntax_context_data[ctxt.0 as usize].opaque_and_semiopaque
     }
 
+    #[inline]
     fn outer_expn(&self, ctxt: SyntaxContext) -> ExpnId {
         self.syntax_context_data[ctxt.0 as usize].outer_expn
     }
 
+    #[inline]
     fn outer_mark(&self, ctxt: SyntaxContext) -> (ExpnId, Transparency) {
         let data = &self.syntax_context_data[ctxt.0 as usize];
         (data.outer_expn, data.outer_transparency)
     }
 
+    #[inline]
     fn parent_ctxt(&self, ctxt: SyntaxContext) -> SyntaxContext {
         self.syntax_context_data[ctxt.0 as usize].parent
     }
@@ -572,35 +578,32 @@ impl HygieneData {
         }
 
         // Reserve a new syntax context.
-        // The inserted dummy data can only be potentially accessed by nested `alloc_ctxt` calls,
-        // the assert below ensures that it doesn't happen.
         let ctxt = SyntaxContext::from_usize(self.syntax_context_data.len());
         self.syntax_context_data
             .push(SyntaxContextData { dollar_crate_name: sym::dummy, ..SyntaxContextData::root() });
         self.syntax_context_map.insert(key, ctxt);
 
-        // Opaque and semi-opaque versions of the parent. Note that they may be equal to the
-        // parent itself. E.g. `parent_opaque` == `parent` if the expn chain contains only opaques,
-        // and `parent_opaque_and_semiopaque` == `parent` if the expn contains only (semi-)opaques.
+        // Get parent data
         let parent_data = &self.syntax_context_data[parent.0 as usize];
         assert_ne!(parent_data.dollar_crate_name, sym::dummy);
         let parent_opaque = parent_data.opaque;
         let parent_opaque_and_semiopaque = parent_data.opaque_and_semiopaque;
 
-        // Evaluate opaque and semi-opaque versions of the new syntax context.
+        // Evaluate opaque and semi-opaque versions iteratively to avoid recursive calls
         let (opaque, opaque_and_semiopaque) = match transparency {
             Transparency::Transparent => (parent_opaque, parent_opaque_and_semiopaque),
-            Transparency::SemiOpaque => (
-                parent_opaque,
-                // Will be the same as `ctxt` if the expn chain contains only (semi-)opaques.
-                self.alloc_ctxt(parent_opaque_and_semiopaque, expn_id, transparency),
-            ),
-            Transparency::Opaque => (
-                // Will be the same as `ctxt` if the expn chain contains only opaques.
-                self.alloc_ctxt(parent_opaque, expn_id, transparency),
-                // Will be the same as `ctxt` if the expn chain contains only (semi-)opaques.
-                self.alloc_ctxt(parent_opaque_and_semiopaque, expn_id, transparency),
-            ),
+            Transparency::SemiOpaque => {
+                let opaque = parent_opaque;
+                let semi_opaque =
+                    self.alloc_ctxt_if_needed(parent_opaque_and_semiopaque, expn_id, transparency);
+                (opaque, semi_opaque)
+            }
+            Transparency::Opaque => {
+                let opaque = self.alloc_ctxt_if_needed(parent_opaque, expn_id, transparency);
+                let semi_opaque =
+                    self.alloc_ctxt_if_needed(parent_opaque_and_semiopaque, expn_id, transparency);
+                (opaque, semi_opaque)
+            }
         };
 
         // Fill the full data, now that we have it.
@@ -614,6 +617,31 @@ impl HygieneData {
         };
         ctxt
     }
+
+    /// Helper to allocate context only if it would be different from the current one.
+    /// This avoids unnecessary recursive calls in common cases.
+    #[inline]
+    fn alloc_ctxt_if_needed(
+        &mut self,
+        parent: SyntaxContext,
+        expn_id: ExpnId,
+        transparency: Transparency,
+    ) -> SyntaxContext {
+        // Fast path: if parent would be the same, return current context being built
+        let current_idx = self.syntax_context_data.len() - 1;
+        if parent.0 as usize == current_idx {
+            return SyntaxContext::from_usize(current_idx);
+        }
+
+        // Check cache first
+        let key = (parent, expn_id, transparency);
+        if let Some(ctxt) = self.syntax_context_map.get(&key) {
+            return *ctxt;
+        }
+
+        // Need to compute
+        self.alloc_ctxt(parent, expn_id, transparency)
+    }
 }
 
 pub fn walk_chain(span: Span, to: SyntaxContext) -> Span {
@@ -718,11 +746,13 @@ impl SyntaxContext {
         SyntaxContext(raw as u32)
     }
 
+    #[inline]
     fn from_usize(raw: usize) -> SyntaxContext {
         SyntaxContext(u32::try_from(raw).unwrap())
     }
 
     /// Extend a syntax context with a given expansion and transparency.
+    #[inline]
     pub fn apply_mark(self, expn_id: ExpnId, transparency: Transparency) -> SyntaxContext {
         HygieneData::with(|data| data.apply_mark(self, expn_id, transparency))
     }
@@ -743,10 +773,12 @@ impl SyntaxContext {
     /// of g (call it g1), calling remove_mark will result in the SyntaxContext for the
     /// invocation of f that created g1.
     /// Returns the mark that was removed.
+    #[inline]
     pub fn remove_mark(&mut self) -> ExpnId {
         HygieneData::with(|data| data.remove_mark(self).0)
     }
 
+    #[inline]
     pub fn marks(self) -> Vec<(ExpnId, Transparency)> {
         HygieneData::with(|data| data.marks(self))
     }
@@ -776,11 +808,13 @@ impl SyntaxContext {
     /// ```
     /// This returns the expansion whose definition scope we use to privacy check the resolution,
     /// or `None` if we privacy check as usual (i.e., not w.r.t. a macro definition scope).
+    #[inline]
     pub fn adjust(&mut self, expn_id: ExpnId) -> Option<ExpnId> {
         HygieneData::with(|data| data.adjust(self, expn_id))
     }
 
     /// Like `SyntaxContext::adjust`, but also normalizes `self` to macros 2.0.
+    #[inline]
     pub(crate) fn normalize_to_macros_2_0_and_adjust(&mut self, expn_id: ExpnId) -> Option<ExpnId> {
         HygieneData::with(|data| {
             *self = data.normalize_to_macros_2_0(*self);
@@ -901,10 +935,12 @@ impl SyntaxContext {
         HygieneData::with(|data| data.outer_mark(self))
     }
 
+    #[inline]
     pub(crate) fn dollar_crate_name(self) -> Symbol {
         HygieneData::with(|data| data.syntax_context_data[self.0 as usize].dollar_crate_name)
     }
 
+    #[inline]
     pub fn edition(self) -> Edition {
         HygieneData::with(|data| data.expn_data(data.outer_expn(self)).edition)
     }