cleanup dependence of ExtCtxt in transcribe when macro expansion

Author: SparrowLii

compiler/rustc_expand/src/mbe/macro_rules.rs

@@ -224,7 +224,8 @@ fn expand_macro<'cx>(
 let arm_span = rhses[i].span();
 
 // rhs has holes ( `$id` and `$(...)` that need filled)
-let tts = matchtranscribe(cx,&named_matches, rhs, rhs_span, transparency){
+let id = cx.current_expansion.id;
+let tts = matchtranscribe(psess,&named_matches, rhs, rhs_span, transparency, id){
 Ok(tts) => tts,
 Err(err) => {
 let guar = err.emit();

compiler/rustc_expand/src/mbe/transcribe.rs

@@ -1,4 +1,3 @@
-usecrate::base::ExtCtxt;
 usecrate::errors::{
 CountRepetitionMisplaced,MetaVarExprUnrecognizedVar,MetaVarsDifSeqMatchers,MustRepeatOnce,
 NoSyntaxVarsExprRepeat,VarStillRepeating,
@@ -9,12 +8,13 @@ use rustc_ast::mut_visit::{self, MutVisitor};
 use rustc_ast::token::{self,Delimiter,Token,TokenKind};
 use rustc_ast::tokenstream::{DelimSpacing,DelimSpan,Spacing,TokenStream,TokenTree};
 use rustc_data_structures::fx::FxHashMap;
-use rustc_errors::{pluralize,Diag,PResult};
+use rustc_errors::{pluralize,Diag,DiagCtxt,PResult};
 use rustc_parse::parser::ParseNtResult;
 use rustc_span::hygiene::{LocalExpnId,Transparency};
 use rustc_span::symbol::{sym,Ident,MacroRulesNormalizedIdent};
 use rustc_span::{with_metavar_spans,Span,SyntaxContext};
 
+use rustc_session::parse::ParseSess;
 use smallvec::{smallvec,SmallVec};
 use std::mem;
 
@@ -99,11 +99,12 @@ impl<'a> Iterator for Frame<'a> {
 ///
 /// Along the way, we do some additional error checking.
 pub(super)fntranscribe<'a>(
-cx:&ExtCtxt<'a>,
+psess:&'aParseSess,
 interp:&FxHashMap<MacroRulesNormalizedIdent,NamedMatch>,
 src:&mbe::Delimited,
 src_span:DelimSpan,
 transparency:Transparency,
+expand_id:LocalExpnId,
 ) -> PResult<'a,TokenStream>{
 // Nothing for us to transcribe...
 if src.tts.is_empty(){
@@ -137,8 +138,9 @@ pub(super) fn transcribe<'a>(
 // again, and we are done transcribing.
 letmut result:Vec<TokenTree> = Vec::new();
 letmut result_stack = Vec::new();
-letmut marker = Marker(cx.current_expansion.id, transparency,Default::default());
+letmut marker = Marker(expand_id, transparency,Default::default());
 
+let dcx = &psess.dcx;
 loop{
 // Look at the last frame on the stack.
 // If it still has a TokenTree we have not looked at yet, use that tree.
@@ -201,19 +203,17 @@ pub(super) fn transcribe<'a>(
  seq @ mbe::TokenTree::Sequence(_, seq_rep) => {
 matchlockstep_iter_size(seq, interp,&repeats){
 LockstepIterSize::Unconstrained => {
-returnErr(cx
-.dcx()
-.create_err(NoSyntaxVarsExprRepeat{span: seq.span()}));
+returnErr(dcx.create_err(NoSyntaxVarsExprRepeat{span: seq.span()}));
 }
 
 LockstepIterSize::Contradiction(msg) => {
 // FIXME: this really ought to be caught at macro definition time... It
 // happens when two meta-variables are used in the same repetition in a
 // sequence, but they come from different sequence matchers and repeat
 // different amounts.
-returnErr(cx
-.dcx()
-.create_err(MetaVarsDifSeqMatchers{span: seq.span(), msg }));
+returnErr(
+ dcx.create_err(MetaVarsDifSeqMatchers{span: seq.span(), msg })
+);
 }
 
 LockstepIterSize::Constraint(len, _) => {
@@ -227,9 +227,7 @@ pub(super) fn transcribe<'a>(
 // FIXME: this really ought to be caught at macro definition
 // time... It happens when the Kleene operator in the matcher and
 // the body for the same meta-variable do not match.
-returnErr(cx
-.dcx()
-.create_err(MustRepeatOnce{span: sp.entire()}));
+returnErr(dcx.create_err(MustRepeatOnce{span: sp.entire()}));
 }
 }else{
 // 0 is the initial counter (we have done 0 repetitions so far). `len`
@@ -259,7 +257,7 @@ pub(super) fn transcribe<'a>(
 MatchedSingle(ParseNtResult::Tt(tt)) => {
 // `tt`s are emitted into the output stream directly as "raw tokens",
 // without wrapping them into groups.
-maybe_use_metavar_location(cx,&stack, sp, tt,&mut marker)
+maybe_use_metavar_location(psess,&stack, sp, tt,&mut marker)
 }
 MatchedSingle(ParseNtResult::Ident(ident, is_raw)) => {
  marker.visit_span(&mut sp);
@@ -280,7 +278,7 @@ pub(super) fn transcribe<'a>(
 }
 MatchedSeq(..) => {
 // We were unable to descend far enough. This is an error.
-returnErr(cx.dcx().create_err(VarStillRepeating{span: sp, ident }));
+returnErr(dcx.create_err(VarStillRepeating{span: sp, ident }));
 }
 };
  result.push(tt)
@@ -299,7 +297,7 @@ pub(super) fn transcribe<'a>(
 
 // Replace meta-variable expressions with the result of their expansion.
  mbe::TokenTree::MetaVarExpr(sp, expr) => {
-transcribe_metavar_expr(cx, expr, interp,&mut marker,&repeats,&mut result, sp)?;
+transcribe_metavar_expr(dcx, expr, interp,&mut marker,&repeats,&mut result, sp)?;
 }
 
 // If we are entering a new delimiter, we push its contents to the `stack` to be
@@ -359,7 +357,7 @@ pub(super) fn transcribe<'a>(
 /// combine with each other and not with tokens outside of the sequence.
 /// - The metavariable span comes from a different crate, then we prefer the more local span.
 fnmaybe_use_metavar_location(
-cx:&ExtCtxt<'_>,
+psess:&ParseSess,
 stack:&[Frame<'_>],
 mutmetavar_span:Span,
 orig_tt:&TokenTree,
@@ -397,7 +395,7 @@ fn maybe_use_metavar_location(
  && insert(mspans, dspan.entire(), metavar_span)
 }),
 };
-if no_collision || cx.source_map().is_imported(metavar_span){
+if no_collision || psess.source_map().is_imported(metavar_span){
 return orig_tt.clone();
 }
 
@@ -558,7 +556,7 @@ fn lockstep_iter_size(
 /// * `[ $( ${count(foo, 1)} ),* ]` will return an error because `${count(foo, 1)}` is
 /// declared inside a single repetition and the index `1` implies two nested repetitions.
 fncount_repetitions<'a>(
-cx:&ExtCtxt<'a>,
+dcx:&'aDiagCtxt,
 depth_user:usize,
 mutmatched:&NamedMatch,
 repeats:&[(usize,usize)],
@@ -595,7 +593,7 @@ fn count_repetitions<'a>(
 .and_then(|el| el.checked_sub(repeats.len()))
 .unwrap_or_default();
 if depth_user > depth_max {
-returnErr(out_of_bounds_err(cx, depth_max + 1, sp.entire(),"count"));
+returnErr(out_of_bounds_err(dcx, depth_max + 1, sp.entire(),"count"));
 }
 
 // `repeats` records all of the nested levels at which we are currently
@@ -611,15 +609,15 @@ fn count_repetitions<'a>(
 }
 
 ifletMatchedSingle(_) = matched {
-returnErr(cx.dcx().create_err(CountRepetitionMisplaced{span: sp.entire()}));
+returnErr(dcx.create_err(CountRepetitionMisplaced{span: sp.entire()}));
 }
 
 count(depth_user, depth_max, matched)
 }
 
 /// Returns a `NamedMatch` item declared on the LHS given an arbitrary [Ident]
 fnmatched_from_ident<'ctx,'interp,'rslt>(
-cx:&ExtCtxt<'ctx>,
+dcx:&'ctxDiagCtxt,
 ident:Ident,
 interp:&'interpFxHashMap<MacroRulesNormalizedIdent,NamedMatch>,
 ) -> PResult<'ctx,&'rsltNamedMatch>
@@ -628,12 +626,12 @@ where
 {
 let span = ident.span;
 let key = MacroRulesNormalizedIdent::new(ident);
- interp.get(&key).ok_or_else(|| cx.dcx().create_err(MetaVarExprUnrecognizedVar{ span, key }))
+ interp.get(&key).ok_or_else(|| dcx.create_err(MetaVarExprUnrecognizedVar{ span, key }))
 }
 
 /// Used by meta-variable expressions when an user input is out of the actual declared bounds. For
 /// example, index(999999) in an repetition of only three elements.
-fnout_of_bounds_err<'a>(cx:&ExtCtxt<'a>,max:usize,span:Span,ty:&str) -> Diag<'a>{
+fnout_of_bounds_err<'a>(dcx:&'aDiagCtxt,max:usize,span:Span,ty:&str) -> Diag<'a>{
 let msg = if max == 0{
 format!(
 "meta-variable expression `{ty}` with depth parameter \
@@ -645,11 +643,11 @@ fn out_of_bounds_err<'a>(cx: &ExtCtxt<'a>, max: usize, span: Span, ty: &str) ->
  must be less than {max}"
 )
 };
-cx.dcx().struct_span_err(span, msg)
+ dcx.struct_span_err(span, msg)
 }
 
 fntranscribe_metavar_expr<'a>(
-cx:&ExtCtxt<'a>,
+dcx:&'aDiagCtxt,
 expr:&MetaVarExpr,
 interp:&FxHashMap<MacroRulesNormalizedIdent,NamedMatch>,
 marker:&mutMarker,
@@ -664,8 +662,8 @@ fn transcribe_metavar_expr<'a>(
 };
 match*expr {
 MetaVarExpr::Count(original_ident, depth) => {
-let matched = matched_from_ident(cx, original_ident, interp)?;
-let count = count_repetitions(cx, depth, matched, repeats, sp)?;
+let matched = matched_from_ident(dcx, original_ident, interp)?;
+let count = count_repetitions(dcx, depth, matched, repeats, sp)?;
 let tt = TokenTree::token_alone(
 TokenKind::lit(token::Integer, sym::integer(count),None),
 visited_span(),
@@ -674,7 +672,7 @@ fn transcribe_metavar_expr<'a>(
 }
 MetaVarExpr::Ignore(original_ident) => {
 // Used to ensure that `original_ident` is present in the LHS
-let _ = matched_from_ident(cx, original_ident, interp)?;
+let _ = matched_from_ident(dcx, original_ident, interp)?;
 }
 MetaVarExpr::Index(depth) => match repeats.iter().nth_back(depth){
 Some((index, _)) => {
@@ -683,7 +681,7 @@ fn transcribe_metavar_expr<'a>(
 visited_span(),
 ));
 }
-None => returnErr(out_of_bounds_err(cx, repeats.len(), sp.entire(),"index")),
+None => returnErr(out_of_bounds_err(dcx, repeats.len(), sp.entire(),"index")),
 },
 MetaVarExpr::Len(depth) => match repeats.iter().nth_back(depth){
 Some((_, length)) => {
@@ -692,7 +690,7 @@ fn transcribe_metavar_expr<'a>(
 visited_span(),
 ));
 }
-None => returnErr(out_of_bounds_err(cx, repeats.len(), sp.entire(),"len")),
+None => returnErr(out_of_bounds_err(dcx, repeats.len(), sp.entire(),"len")),
 },
 }
 Ok(())