Skip to content
This repository was archived by the owner on May 28, 2025. It is now read-only.

Commit 6aefb26

Browse files
borsbors
committed
Auto merge of rust-lang#119412 - petrochenkov:dialoc3, r=<try>
macro_rules: Remove `NtIdent` nonterminal token It only exists for keeping the second span (the metavariable span), but after rust-lang#119673 such spans can be kept using a more general mechanism.
2 parents d40f30e + 114504f commit 6aefb26

File tree

52 files changed

+198
-532
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

52 files changed

+198
-532
lines changed

‎compiler/rustc_ast/src/mut_visit.rs

Lines changed: 0 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -778,9 +778,6 @@ pub fn visit_token<T: MutVisitor>(t: &mut Token, vis: &mut T) {
778778
*span = ident.span;
779779
return; // Avoid visiting the span for the second time.
780780
}
781-
token::NtIdent(ident, _is_raw) => {
782-
vis.visit_ident(ident);
783-
}
784781
token::NtLifetime(ident) => {
785782
vis.visit_ident(ident);
786783
}

‎compiler/rustc_ast/src/token.rs

Lines changed: 3 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -315,14 +315,7 @@ pub enum TokenKind {
315315
Literal(Lit),
316316

317317
/// Identifier token.
318-
/// Do not forget about `NtIdent` when you want to match on identifiers.
319-
/// It's recommended to use `Token::(ident,uninterpolate,uninterpolated_span)` to
320-
/// treat regular and interpolated identifiers in the same way.
321318
Ident(Symbol, IdentIsRaw),
322-
/// This identifier (and its span) is the identifier passed to the
323-
/// declarative macro. The span in the surrounding `Token` is the span of
324-
/// the `ident` metavariable in the macro's RHS.
325-
NtIdent(Ident, IdentIsRaw),
326319

327320
/// Lifetime identifier token.
328321
/// Do not forget about `NtLifetime` when you want to match on lifetime identifiers.
@@ -455,7 +448,7 @@ impl Token {
455448
/// if they keep spans or perform edition checks.
456449
pub fn uninterpolated_span(&self) -> Span {
457450
match self.kind {
458-
NtIdent(ident, _) | NtLifetime(ident) => ident.span,
451+
NtLifetime(ident) => ident.span,
459452
Interpolated(ref nt) => nt.use_span(),
460453
_ => self.span,
461454
}
@@ -474,7 +467,7 @@ impl Token {
474467
}
475468

476469
OpenDelim(..) | CloseDelim(..) | Literal(..) | DocComment(..) | Ident(..)
477-
| NtIdent(..) | Lifetime(..) | NtLifetime(..) | Interpolated(..) | Eof => false,
470+
| Lifetime(..) | NtLifetime(..) | Interpolated(..) | Eof => false,
478471
}
479472
}
480473

@@ -642,7 +635,6 @@ impl Token {
642635
/// otherwise returns the original token.
643636
pub fn uninterpolate(&self) -> Cow<'_, Token> {
644637
match self.kind {
645-
NtIdent(ident, is_raw) => Cow::Owned(Token::new(Ident(ident.name, is_raw), ident.span)),
646638
NtLifetime(ident) => Cow::Owned(Token::new(Lifetime(ident.name), ident.span)),
647639
_ => Cow::Borrowed(self),
648640
}
@@ -654,7 +646,6 @@ impl Token {
654646
// We avoid using `Token::uninterpolate` here because it's slow.
655647
match self.kind {
656648
Ident(name, is_raw) => Some((Ident::new(name, self.span), is_raw)),
657-
NtIdent(ident, is_raw) => Some((ident, is_raw)),
658649
_ => None,
659650
}
660651
}
@@ -854,7 +845,7 @@ impl Token {
854845

855846
Le | EqEq | Ne | Ge | AndAnd | OrOr | Tilde | BinOpEq(..) | At | DotDotDot
856847
| DotDotEq | Comma | Semi | PathSep | RArrow | LArrow | FatArrow | Pound | Dollar
857-
| Question | OpenDelim(..) | CloseDelim(..) | Literal(..) | Ident(..) | NtIdent(..)
848+
| Question | OpenDelim(..) | CloseDelim(..) | Literal(..) | Ident(..)
858849
| Lifetime(..) | NtLifetime(..) | Interpolated(..) | DocComment(..) | Eof => {
859850
return None;
860851
}

‎compiler/rustc_ast/src/tokenstream.rs

Lines changed: 3 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -484,9 +484,6 @@ impl TokenStream {
484484

485485
fn flatten_token(token: &Token, spacing: Spacing) -> TokenTree {
486486
match token.kind {
487-
token::NtIdent(ident, is_raw) => {
488-
TokenTree::Token(Token::new(token::Ident(ident.name, is_raw), ident.span), spacing)
489-
}
490487
token::NtLifetime(ident) => TokenTree::Delimited(
491488
DelimSpan::from_single(token.span),
492489
DelimSpacing::new(Spacing::JointHidden, spacing),
@@ -516,10 +513,9 @@ impl TokenStream {
516513
pub fn flattened(&self) -> TokenStream {
517514
fn can_skip(stream: &TokenStream) -> bool {
518515
stream.trees().all(|tree| match tree {
519-
TokenTree::Token(token, _) => !matches!(
520-
token.kind,
521-
token::NtIdent(..) | token::NtLifetime(..) | token::Interpolated(..)
522-
),
516+
TokenTree::Token(token, _) => {
517+
!matches!(token.kind, token::NtLifetime(..) | token::Interpolated(..))
518+
}
523519
TokenTree::Delimited(.., inner) => can_skip(inner),
524520
})
525521
}

‎compiler/rustc_ast_pretty/src/pprust/state.rs

Lines changed: 0 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -943,9 +943,6 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
943943
token::Ident(name, is_raw) => {
944944
IdentPrinter::new(name, is_raw.into(), convert_dollar_crate).to_string().into()
945945
}
946-
token::NtIdent(ident, is_raw) => {
947-
IdentPrinter::for_ast_ident(ident, is_raw.into()).to_string().into()
948-
}
949946
token::Lifetime(name) => name.to_string().into(),
950947
token::NtLifetime(ident) => ident.name.to_string().into(),
951948

‎compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs

Lines changed: 9 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -743,9 +743,11 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
743743
// or
744744
// `fn foo(&x: &i32)` -> `fn foo(&(mut x): &i32)`
745745
let def_id = self.body.source.def_id();
746-
if let Some(local_def_id) = def_id.as_local()
747-
&& let Some(body) = self.infcx.tcx.hir().maybe_body_owned_by(local_def_id)
748-
&& let Some(hir_id) = (BindingFinder { span: pat_span }).visit_body(&body).break_value()
746+
let hir_id = def_id
747+
.as_local()
748+
.and_then(|def_id| self.infcx.tcx.hir().maybe_body_owned_by(def_id))
749+
.and_then(|body| (BindingFinder { span: pat_span }).visit_body(&body).break_value());
750+
if let Some(hir_id) = hir_id
749751
&& let node = self.infcx.tcx.hir_node(hir_id)
750752
&& let hir::Node::LetStmt(hir::LetStmt {
751753
pat: hir::Pat { kind: hir::PatKind::Ref(_, _), .. },
@@ -767,8 +769,11 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
767769
return;
768770
}
769771

772+
let span = local_decl.source_info.span;
773+
let span =
774+
hir_id.map_or(span, |hir_id| span.with_neighbor(self.infcx.tcx.hir().span(hir_id)));
770775
err.span_suggestion_verbose(
771-
local_decl.source_info.span.shrink_to_lo(),
776+
span.shrink_to_lo(),
772777
"consider changing this to be mutable",
773778
"mut ",
774779
Applicability::MachineApplicable,

‎compiler/rustc_expand/src/config.rs

Lines changed: 1 addition & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -203,13 +203,7 @@ impl<'a> StripUnconfigured<'a> {
203203
Some(AttrTokenTree::Delimited(sp, spacing, delim, inner)).into_iter()
204204
}
205205
AttrTokenTree::Token(
206-
Token {
207-
kind:
208-
TokenKind::NtIdent(..)
209-
| TokenKind::NtLifetime(..)
210-
| TokenKind::Interpolated(..),
211-
..
212-
},
206+
Token { kind: TokenKind::NtLifetime(..) | TokenKind::Interpolated(..), .. },
213207
_,
214208
) => {
215209
panic!("Nonterminal should have been flattened: {:?}", tree);

‎compiler/rustc_expand/src/mbe/transcribe.rs

Lines changed: 20 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -274,11 +274,6 @@ pub(super) fn transcribe<'a>(
274274
// without wrapping them into groups.
275275
maybe_use_metavar_location(psess, &stack, sp, tt, &mut marker)
276276
}
277-
MatchedSingle(ParseNtResult::Ident(ident, is_raw)) => {
278-
marker.visit_span(&mut sp);
279-
let kind = token::NtIdent(*ident, *is_raw);
280-
TokenTree::token_alone(kind, sp)
281-
}
282277
MatchedSingle(ParseNtResult::Lifetime(ident)) => {
283278
marker.visit_span(&mut sp);
284279
let kind = token::NtLifetime(*ident);
@@ -395,9 +390,22 @@ fn maybe_use_metavar_location(
395390
return orig_tt.clone();
396391
}
397392

398-
let insert = |mspans: &mut FxHashMap<_, _>, s, ms| match mspans.try_insert(s, ms) {
393+
let insert = |mspans: &mut FxHashMap<_, _>, s, ms: Span| match mspans.try_insert(s, ms) {
399394
Ok(_) => true,
400-
Err(err) => *err.entry.get() == ms, // Tried to insert the same span, still success
395+
Err(mut err) => {
396+
let old_ms = *err.entry.get();
397+
if ms == old_ms {
398+
// Tried to insert the same span, still success.
399+
return true;
400+
}
401+
if !ms.eq_ctxt(old_ms) && ms.ctxt().outer_expn_data().call_site.eq_ctxt(old_ms) {
402+
// This looks like a variable passed to an inner (possibly recursive) macro call.
403+
// The innermost metavar span is the most useful, so override.
404+
err.entry.insert(ms);
405+
return true;
406+
}
407+
false
408+
}
401409
};
402410
marker.visit_span(&mut metavar_span);
403411
let no_collision = match orig_tt {
@@ -411,16 +419,19 @@ fn maybe_use_metavar_location(
411419
}),
412420
};
413421
if no_collision || psess.source_map().is_imported(metavar_span) {
422+
if let TokenTree::Token(token, _) = orig_tt {
423+
return TokenTree::Token(token.clone(), Spacing::Alone);
424+
}
414425
return orig_tt.clone();
415426
}
416427

417428
// Setting metavar spans for the heuristic spans gives better opportunities for combining them
418429
// with neighboring spans even despite their different syntactic contexts.
419430
match orig_tt {
420-
TokenTree::Token(Token { kind, span }, spacing) => {
431+
TokenTree::Token(Token { kind, span }, _spacing) => {
421432
let span = metavar_span.with_ctxt(span.ctxt());
422433
with_metavar_spans(|mspans| insert(mspans, span, metavar_span));
423-
TokenTree::Token(Token { kind: kind.clone(), span }, *spacing)
434+
TokenTree::Token(Token { kind: kind.clone(), span }, Spacing::Alone)
424435
}
425436
TokenTree::Delimited(dspan, dspacing, delimiter, tts) => {
426437
let open = metavar_span.with_ctxt(dspan.open.ctxt());
@@ -735,12 +746,6 @@ fn extract_ident<'a>(
735746
interp: &FxHashMap<MacroRulesNormalizedIdent, NamedMatch>,
736747
) -> PResult<'a, String> {
737748
if let NamedMatch::MatchedSingle(pnr) = matched_from_ident(dcx, ident, interp)? {
738-
if let ParseNtResult::Ident(nt_ident, is_raw) = pnr {
739-
if let IdentIsRaw::Yes = is_raw {
740-
return Err(dcx.struct_span_err(ident.span, RAW_IDENT_ERR));
741-
}
742-
return Ok(nt_ident.to_string());
743-
}
744749
if let ParseNtResult::Tt(TokenTree::Token(
745750
Token { kind: TokenKind::Ident(token_ident, is_raw), .. },
746751
_,

‎compiler/rustc_expand/src/proc_macro_server.rs

Lines changed: 0 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -221,11 +221,6 @@ impl FromInternal<(TokenStream, &mut Rustc<'_, '_>)> for Vec<TokenTree<TokenStre
221221
Ident(sym, is_raw) => {
222222
trees.push(TokenTree::Ident(Ident { sym, is_raw: is_raw.into(), span }))
223223
}
224-
NtIdent(ident, is_raw) => trees.push(TokenTree::Ident(Ident {
225-
sym: ident.name,
226-
is_raw: is_raw.into(),
227-
span: ident.span,
228-
})),
229224

230225
Lifetime(name) => {
231226
let ident = symbol::Ident::new(name, span).without_first_quote();

‎compiler/rustc_hir_analysis/src/hir_ty_lowering/lint.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -56,7 +56,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
5656
));
5757
}
5858

59-
if self_ty.span.edition().at_least_rust_2021() {
59+
if tcx.hir().span_in_context(self_ty.hir_id).edition().at_least_rust_2021() {
6060
let msg = "trait objects must include the `dyn` keyword";
6161
let label = "add `dyn` keyword before this trait";
6262
let mut diag =

‎compiler/rustc_hir_typeck/src/method/suggest.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2454,7 +2454,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
24542454
ExprKind::Path(QPath::Resolved(_, path)) => {
24552455
// local binding
24562456
if let hir::def::Res::Local(hir_id) = path.res {
2457-
let span = tcx.hir().span(hir_id);
2457+
let span = tcx.hir().span_in_context(hir_id);
24582458
let filename = tcx.sess.source_map().span_to_filename(span);
24592459

24602460
let parent_node = self.tcx.parent_hir_node(hir_id);

‎compiler/rustc_lint/src/types.rs

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -718,8 +718,9 @@ fn lint_wide_pointer<'tcx>(
718718
return;
719719
};
720720

721+
let (l_span, r_span) = (l.span.with_neighbor(e.span), r.span.with_neighbor(e.span));
721722
let (Some(l_span), Some(r_span)) =
722-
(l.span.find_ancestor_inside(e.span), r.span.find_ancestor_inside(e.span))
723+
(l_span.find_ancestor_inside(e.span), r_span.find_ancestor_inside(e.span))
723724
else {
724725
return cx.emit_span_lint(
725726
AMBIGUOUS_WIDE_POINTER_COMPARISONS,

‎compiler/rustc_middle/src/hir/map/mod.rs

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -935,6 +935,11 @@ impl<'hir> Map<'hir> {
935935
}
936936
}
937937

938+
pub fn span_in_context(self, hir_id: HirId) -> Span {
939+
let parent_span = self.span(self.tcx.parent_hir_id(hir_id));
940+
self.span(hir_id).with_neighbor(parent_span)
941+
}
942+
938943
/// Get a representation of this `id` for debugging purposes.
939944
/// NOTE: Do NOT use this in diagnostics!
940945
pub fn node_to_string(self, id: HirId) -> String {

‎compiler/rustc_parse/src/parser/attr_wrapper.rs

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -230,8 +230,7 @@ impl<'a> Parser<'a> {
230230
let (mut ret, trailing) = ret?;
231231

232232
// When we're not in `capture-cfg` mode, then bail out early if:
233-
// 1. Our target doesn't support tokens at all (e.g we're parsing an `NtIdent`)
234-
// so there's nothing for us to do.
233+
// 1. Our target doesn't support tokens at all, so there's nothing for us to do.
235234
// 2. Our target already has tokens set (e.g. we've parsed something
236235
// like `#[my_attr] $item`. The actual parsing code takes care of prepending
237236
// any attributes to the nonterminal, so we don't need to modify the

‎compiler/rustc_parse/src/parser/expr.rs

Lines changed: 10 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -279,10 +279,11 @@ impl<'a> Parser<'a> {
279279
continue;
280280
}
281281

282+
let op_span = op.span;
282283
let op = op.node;
283284
// Special cases:
284285
if op == AssocOp::As {
285-
lhs = self.parse_assoc_op_cast(lhs, lhs_span, ExprKind::Cast)?;
286+
lhs = self.parse_assoc_op_cast(lhs, lhs_span, op_span, ExprKind::Cast)?;
286287
continue;
287288
} else if op == AssocOp::DotDot || op == AssocOp::DotDotEq {
288289
// If we didn't have to handle `x..`/`x..=`, it would be pretty easy to
@@ -304,7 +305,7 @@ impl<'a> Parser<'a> {
304305
this.parse_expr_assoc_with(prec + prec_adjustment, LhsExpr::Unparsed { attrs })
305306
})?;
306307

307-
let span = self.mk_expr_sp(&lhs, lhs_span, rhs.span);
308+
let span = self.mk_expr_sp(&lhs, lhs_span, op_span, rhs.span);
308309
lhs = match op {
309310
AssocOp::Add
310311
| AssocOp::Subtract
@@ -483,7 +484,7 @@ impl<'a> Parser<'a> {
483484
None
484485
};
485486
let rhs_span = rhs.as_ref().map_or(cur_op_span, |x| x.span);
486-
let span = self.mk_expr_sp(&lhs, lhs.span, rhs_span);
487+
let span = self.mk_expr_sp(&lhs, lhs.span, cur_op_span, rhs_span);
487488
let limits =
488489
if op == AssocOp::DotDot { RangeLimits::HalfOpen } else { RangeLimits::Closed };
489490
let range = self.mk_range(Some(lhs), rhs, limits);
@@ -693,9 +694,7 @@ impl<'a> Parser<'a> {
693694
/// Returns the span of expr if it was not interpolated, or the span of the interpolated token.
694695
fn interpolated_or_expr_span(&self, expr: &Expr) -> Span {
695696
match self.prev_token.kind {
696-
TokenKind::NtIdent(..) | TokenKind::NtLifetime(..) | TokenKind::Interpolated(..) => {
697-
self.prev_token.span
698-
}
697+
TokenKind::NtLifetime(..) | TokenKind::Interpolated(..) => self.prev_token.span,
699698
_ => expr.span,
700699
}
701700
}
@@ -704,10 +703,11 @@ impl<'a> Parser<'a> {
704703
&mut self,
705704
lhs: P<Expr>,
706705
lhs_span: Span,
706+
op_span: Span,
707707
expr_kind: fn(P<Expr>, P<Ty>) -> ExprKind,
708708
) -> PResult<'a, P<Expr>> {
709709
let mk_expr = |this: &mut Self, lhs: P<Expr>, rhs: P<Ty>| {
710-
this.mk_expr(this.mk_expr_sp(&lhs, lhs_span, rhs.span), expr_kind(lhs, rhs))
710+
this.mk_expr(this.mk_expr_sp(&lhs, lhs_span, op_span, rhs.span), expr_kind(lhs, rhs))
711711
};
712712

713713
// Save the state of the parser before parsing type normally, in case there is a
@@ -3842,11 +3842,13 @@ impl<'a> Parser<'a> {
38423842

38433843
/// Create expression span ensuring the span of the parent node
38443844
/// is larger than the span of lhs and rhs, including the attributes.
3845-
fn mk_expr_sp(&self, lhs: &P<Expr>, lhs_span: Span, rhs_span: Span) -> Span {
3845+
fn mk_expr_sp(&self, lhs: &P<Expr>, lhs_span: Span, op_span: Span, rhs_span: Span) -> Span {
38463846
lhs.attrs
38473847
.iter()
38483848
.find(|a| a.style == AttrStyle::Outer)
38493849
.map_or(lhs_span, |a| a.span)
3850+
// An approximation to #126763.
3851+
.to(op_span)
38503852
.to(rhs_span)
38513853
}
38523854

‎compiler/rustc_parse/src/parser/mod.rs

Lines changed: 3 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -394,7 +394,6 @@ pub(super) fn token_descr(token: &Token) -> String {
394394
(Some(TokenDescription::Keyword), _) => Some("keyword"),
395395
(Some(TokenDescription::ReservedKeyword), _) => Some("reserved keyword"),
396396
(Some(TokenDescription::DocComment), _) => Some("doc comment"),
397-
(None, TokenKind::NtIdent(..)) => Some("identifier"),
398397
(None, TokenKind::NtLifetime(..)) => Some("lifetime"),
399398
(None, TokenKind::Interpolated(node)) => Some(node.descr()),
400399
(None, _) => None,
@@ -687,9 +686,9 @@ impl<'a> Parser<'a> {
687686
self.is_keyword_ahead(0, &[kw::Const])
688687
&& self.look_ahead(1, |t| match &t.kind {
689688
// async closures do not work with const closures, so we do not parse that here.
690-
token::Ident(kw::Move | kw::Static, _) | token::OrOr | token::BinOp(token::Or) => {
691-
true
692-
}
689+
token::Ident(kw::Move | kw::Static, IdentIsRaw::No)
690+
| token::OrOr
691+
| token::BinOp(token::Or) => true,
693692
_ => false,
694693
})
695694
}
@@ -1623,7 +1622,6 @@ enum FlatToken {
16231622
#[derive(Clone, Debug)]
16241623
pub enum ParseNtResult {
16251624
Tt(TokenTree),
1626-
Ident(Ident, IdentIsRaw),
16271625
Lifetime(Ident),
16281626

16291627
/// This case will eventually be removed, along with `Token::Interpolate`.

0 commit comments

Comments
 (0)