Move expansion creation methods to TyCtxt.

cjgillot · cjgillot · commit 4feb1b71d1aa · 2023-05-28T08:04:12.000Z
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
@@ -160,7 +160,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     self.lower_expr_if(cond, then, else_opt.as_deref())
                 }
                 ExprKind::While(cond, body, opt_label) => self.with_loop_scope(e.id, |this| {
-                    let span = this.mark_span_with_reason(DesugaringKind::WhileLoop, e.span, None);
+                    let span =
+                        this.tcx.mark_span_with_reason(DesugaringKind::WhileLoop, e.span, None);
                     this.lower_expr_while_in_loop_scope(span, cond, body, *opt_label)
                 }),
                 ExprKind::Loop(body, opt_label, span) => self.with_loop_scope(e.id, |this| {
@@ -448,7 +449,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             _ => {
                 let cond = self.lower_expr(cond);
                 let reason = DesugaringKind::CondTemporary;
-                let span_block = self.mark_span_with_reason(reason, cond.span, None);
+                let span_block = self.tcx.mark_span_with_reason(reason, cond.span, None);
                 self.expr_drop_temps(span_block, cond)
             }
         }
@@ -501,15 +502,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
             // Final expression of the block (if present) or `()` with span at the end of block
             let (try_span, tail_expr) = if let Some(expr) = block.expr.take() {
                 (
-                    this.mark_span_with_reason(
+                    this.tcx.mark_span_with_reason(
                         DesugaringKind::TryBlock,
                         expr.span,
                         this.allow_try_trait.clone(),
                     ),
                     expr,
                 )
             } else {
-                let try_span = this.mark_span_with_reason(
+                let try_span = this.tcx.mark_span_with_reason(
                     DesugaringKind::TryBlock,
                     this.tcx.sess.source_map().end_point(body.span),
                     this.allow_try_trait.clone(),
@@ -519,7 +520,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             };
 
             let ok_wrapped_span =
-                this.mark_span_with_reason(DesugaringKind::TryBlock, tail_expr.span, None);
+                this.tcx.mark_span_with_reason(DesugaringKind::TryBlock, tail_expr.span, None);
 
             // `::std::ops::Try::from_output($tail_expr)`
             block.expr = Some(this.wrap_in_try_constructor(
@@ -591,8 +592,11 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let output = ret_ty.unwrap_or_else(|| hir::FnRetTy::DefaultReturn(self.lower_span(span)));
 
         // Resume argument type: `ResumeTy`
-        let unstable_span =
-            self.mark_span_with_reason(DesugaringKind::Async, span, self.allow_gen_future.clone());
+        let unstable_span = self.tcx.mark_span_with_reason(
+            DesugaringKind::Async,
+            span,
+            self.allow_gen_future.clone(),
+        );
         let resume_ty = hir::QPath::LangItem(hir::LangItem::ResumeTy, unstable_span, None);
         let input_ty = hir::Ty {
             hir_id: self.next_id(),
@@ -661,7 +665,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             && attrs.into_iter().any(|attr| attr.has_name(sym::track_caller))
         {
             let unstable_span =
-                self.mark_span_with_reason(DesugaringKind::Async, span, self.allow_gen_future.clone());
+                self.tcx.mark_span_with_reason(DesugaringKind::Async, span, self.allow_gen_future.clone());
             self.lower_attrs(
                 inner_hir_id,
                 &[Attribute {
@@ -707,8 +711,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 });
             }
         }
-        let span = self.mark_span_with_reason(DesugaringKind::Await, await_kw_span, None);
-        let gen_future_span = self.mark_span_with_reason(
+        let span = self.tcx.mark_span_with_reason(DesugaringKind::Await, await_kw_span, None);
+        let gen_future_span = self.tcx.mark_span_with_reason(
             DesugaringKind::Await,
             full_span,
             self.allow_gen_future.clone(),
@@ -1466,9 +1470,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let head = self.lower_expr_mut(head);
         let pat = self.lower_pat(pat);
         let for_span =
-            self.mark_span_with_reason(DesugaringKind::ForLoop, self.lower_span(e.span), None);
-        let head_span = self.mark_span_with_reason(DesugaringKind::ForLoop, head.span, None);
-        let pat_span = self.mark_span_with_reason(DesugaringKind::ForLoop, pat.span, None);
+            self.tcx.mark_span_with_reason(DesugaringKind::ForLoop, self.lower_span(e.span), None);
+        let head_span = self.tcx.mark_span_with_reason(DesugaringKind::ForLoop, head.span, None);
+        let pat_span = self.tcx.mark_span_with_reason(DesugaringKind::ForLoop, pat.span, None);
 
         // `None => break`
         let none_arm = {
@@ -1562,13 +1566,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
     /// }
     /// ```
     fn lower_expr_try(&mut self, span: Span, sub_expr: &Expr) -> hir::ExprKind<'hir> {
-        let unstable_span = self.mark_span_with_reason(
+        let unstable_span = self.tcx.mark_span_with_reason(
             DesugaringKind::QuestionMark,
             span,
             self.allow_try_trait.clone(),
         );
         let try_span = self.tcx.sess.source_map().end_point(span);
-        let try_span = self.mark_span_with_reason(
+        let try_span = self.tcx.mark_span_with_reason(
             DesugaringKind::QuestionMark,
             try_span,
             self.allow_try_trait.clone(),
@@ -1659,10 +1663,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let (yeeted_span, yeeted_expr) = if let Some(sub_expr) = sub_expr {
             (sub_expr.span, self.lower_expr(sub_expr))
         } else {
-            (self.mark_span_with_reason(DesugaringKind::YeetExpr, span, None), self.expr_unit(span))
+            (
+                self.tcx.mark_span_with_reason(DesugaringKind::YeetExpr, span, None),
+                self.expr_unit(span),
+            )
         };
 
-        let unstable_span = self.mark_span_with_reason(
+        let unstable_span = self.tcx.mark_span_with_reason(
             DesugaringKind::YeetExpr,
             span,
             self.allow_try_trait.clone(),
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
@@ -1071,7 +1071,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     }
                 };
 
-                let desugared_span = this.mark_span_with_reason(DesugaringKind::Async, span, None);
+                let desugared_span =
+                    this.tcx.mark_span_with_reason(DesugaringKind::Async, span, None);
 
                 // Construct a parameter representing `__argN: <ty>` to replace the parameter of the
                 // async function.
@@ -1160,7 +1161,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
                     // Transform into `drop-temps { <user-body> }`, an expression:
                     let desugared_span =
-                        this.mark_span_with_reason(DesugaringKind::Async, user_body.span, None);
+                        this.tcx.mark_span_with_reason(DesugaringKind::Async, user_body.span, None);
                     let user_body =
                         this.expr_drop_temps(desugared_span, this.arena.alloc(user_body));
 
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
@@ -762,19 +762,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         self.tcx.sess.diagnostic()
     }
 
-    /// Reuses the span but adds information like the kind of the desugaring and features that are
-    /// allowed inside this span.
-    fn mark_span_with_reason(
-        &self,
-        reason: DesugaringKind,
-        span: Span,
-        allow_internal_unstable: Option<Lrc<[Symbol]>>,
-    ) -> Span {
-        self.tcx.with_stable_hashing_context(|hcx| {
-            span.mark_with_reason(allow_internal_unstable, reason, self.tcx.sess.edition(), hcx)
-        })
-    }
-
     /// Intercept all spans entering HIR.
     /// Mark a span as relative to the current owning item.
     fn lower_span(&self, span: Span) -> Span {
@@ -1529,7 +1516,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         // desugaring that explicitly states that we don't want to track that.
         // Not tracking it makes lints in rustc and clippy very fragile, as
         // frequently opened issues show.
-        let opaque_ty_span = self.mark_span_with_reason(DesugaringKind::OpaqueTy, span, None);
+        let opaque_ty_span = self.tcx.mark_span_with_reason(DesugaringKind::OpaqueTy, span, None);
 
         let opaque_ty_def_id = self.create_def(
             self.current_hir_id_owner.def_id,
@@ -1893,7 +1880,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
     ) -> hir::FnRetTy<'hir> {
         let span = output.span();
 
-        let opaque_ty_span = self.mark_span_with_reason(DesugaringKind::Async, span, None);
+        let opaque_ty_span = self.tcx.mark_span_with_reason(DesugaringKind::Async, span, None);
 
         let fn_def_id = self.local_def_id(fn_node_id);
 
diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
@@ -486,7 +486,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
                                 .map(|(path, item, _exts, is_const)| {
                                     // FIXME: Consider using the derive resolutions (`_exts`)
                                     // instead of enqueuing the derives to be resolved again later.
-                                    let expn_id = LocalExpnId::fresh_empty();
+                                    let expn_id = LocalExpnId::reserve_expansion_id();
                                     derive_invocations.push((
                                         Invocation {
                                             kind: InvocationKind::Derive { path, item, is_const },
@@ -1548,7 +1548,7 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
     }
 
     fn collect(&mut self, fragment_kind: AstFragmentKind, kind: InvocationKind) -> AstFragment {
-        let expn_id = LocalExpnId::fresh_empty();
+        let expn_id = LocalExpnId::reserve_expansion_id();
         let vis = kind.placeholder_visibility();
         self.invocations.push((
             Invocation {
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
@@ -65,6 +65,7 @@ use rustc_session::Limit;
 use rustc_session::Session;
 use rustc_span::def_id::{DefPathHash, StableCrateId};
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
+use rustc_span::{DesugaringKind, ExpnData, ExpnKind, LocalExpnId};
 use rustc_span::{Span, DUMMY_SP};
 use rustc_target::abi::{FieldIdx, Layout, LayoutS, TargetDataLayout, VariantIdx};
 use rustc_target::spec::abi;
@@ -901,6 +902,38 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 }
 
+impl<'tcx> TyCtxt<'tcx> {
+    #[instrument(level = "trace", skip(self), ret)]
+    pub fn create_expansion(self, expn_data: ExpnData) -> LocalExpnId {
+        self.with_stable_hashing_context(|ctx| {
+            LocalExpnId::create_untracked_expansion(expn_data, ctx)
+        })
+    }
+
+    /// Fill an empty expansion. This method must not be used outside of the resolver.
+    #[inline]
+    #[instrument(level = "trace", skip(self))]
+    pub fn finalize_expansion(self, expn_id: LocalExpnId, expn_data: ExpnData) {
+        self.with_stable_hashing_context(|ctx| expn_id.set_untracked_expn_data(expn_data, ctx));
+    }
+
+    /// Reuses the span but adds information like the kind of the desugaring and features that are
+    /// allowed inside this span.
+    pub fn mark_span_with_reason(
+        self,
+        reason: DesugaringKind,
+        span: Span,
+        allow_internal_unstable: Option<Lrc<[Symbol]>>,
+    ) -> Span {
+        let edition = self.sess.edition();
+        let mut expn_data =
+            ExpnData::default(ExpnKind::Desugaring(reason), span, edition, None, None);
+        expn_data.allow_internal_unstable = allow_internal_unstable;
+        let expn_id = self.create_expansion(expn_data);
+        span.fresh_expansion(expn_id)
+    }
+}
+
 impl<'tcx> TyCtxtAt<'tcx> {
     /// Create a new definition within the incr. comp. engine.
     pub fn create_def(
diff --git a/compiler/rustc_query_system/src/query/plumbing.rs b/compiler/rustc_query_system/src/query/plumbing.rs
@@ -676,6 +676,10 @@ pub(crate) fn incremental_verify_ich<Tcx, V>(
     });
 
     let old_hash = dep_graph_data.prev_fingerprint_of(prev_index);
+    debug!(
+        dep_node = ?tcx.dep_graph().data().unwrap().prev_node_of(prev_index),
+        ?new_hash, ?old_hash,
+    );
 
     if new_hash != old_hash {
         incremental_verify_ich_failed(tcx, prev_index, &|| format_value(&result));
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
@@ -51,7 +51,6 @@ use rustc_middle::query::Providers;
 use rustc_middle::span_bug;
 use rustc_middle::ty::{self, MainDefinition, RegisteredTools, TyCtxt};
 use rustc_middle::ty::{ResolverGlobalCtxt, ResolverOutputs};
-use rustc_query_system::ich::StableHashingContext;
 use rustc_session::lint::LintBuffer;
 use rustc_span::hygiene::{ExpnId, LocalExpnId, MacroKind, SyntaxContext, Transparency};
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
@@ -1445,10 +1444,6 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
         ResolverOutputs { global_ctxt, ast_lowering }
     }
 
-    fn create_stable_hashing_context(&self) -> StableHashingContext<'_> {
-        StableHashingContext::new(self.tcx.sess, self.tcx.untracked())
-    }
-
     fn crate_loader<T>(&mut self, f: impl FnOnce(&mut CrateLoader<'_, '_>) -> T) -> T {
         f(&mut CrateLoader::new(
             self.tcx,
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
@@ -217,17 +217,14 @@ impl<'a, 'tcx> ResolverExpand for Resolver<'a, 'tcx> {
     ) -> LocalExpnId {
         let parent_module =
             parent_module_id.map(|module_id| self.local_def_id(module_id).to_def_id());
-        let expn_id = LocalExpnId::fresh(
-            ExpnData::allow_unstable(
-                ExpnKind::AstPass(pass),
-                call_site,
-                self.tcx.sess.edition(),
-                features.into(),
-                None,
-                parent_module,
-            ),
-            self.create_stable_hashing_context(),
-        );
+        let expn_id = self.tcx.create_expansion(ExpnData::allow_unstable(
+            ExpnKind::AstPass(pass),
+            call_site,
+            self.tcx.sess.edition(),
+            features.into(),
+            None,
+            parent_module,
+        ));
 
         let parent_scope =
             parent_module.map_or(self.empty_module, |def_id| self.expect_module(def_id));
@@ -290,15 +287,15 @@ impl<'a, 'tcx> ResolverExpand for Resolver<'a, 'tcx> {
 
         let span = invoc.span();
         let def_id = res.opt_def_id();
-        invoc_id.set_expn_data(
+        self.tcx.finalize_expansion(
+            invoc_id,
             ext.expn_data(
                 parent_scope.expansion,
                 span,
                 fast_print_path(path),
                 def_id,
                 def_id.map(|def_id| self.macro_def_scope(def_id).nearest_parent_mod()),
             ),
-            self.create_stable_hashing_context(),
         );
 
         Ok(ext)
diff --git a/compiler/rustc_span/src/hygiene.rs b/compiler/rustc_span/src/hygiene.rs
diff --git a/src/librustdoc/passes/lint/check_code_block_syntax.rs b/src/librustdoc/passes/lint/check_code_block_syntax.rs
