Optimize syntax context allocation performance in macro hygiene system

Signed-off-by: xizheyin <xizheyin@smail.nju.edu.cn>

Author: xizheyin

compiler/rustc_span/src/hygiene.rs

@@ -578,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.
@@ -620,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 {