Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings
This repository was archived by the owner on May 28, 2025. It is now read-only.

Commit 2f5db75

Browse files
committed
Auto merge of rust-lang#138478 - nnethercote:rm-NtExpr-NtLiteral, r=<try>
Remove `NtExpr` and `NtLiteral` The next part of rust-lang#124141. r? `@petrochenkov`
2 parents ae8ab87 + 7f6b06c commit 2f5db75

31 files changed

+832
-586
lines changed

‎compiler/rustc_ast/src/ast_traits.rs‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -209,13 +209,11 @@ impl HasTokens for Attribute {
209209
impl HasTokens for Nonterminal {
210210
fn tokens(&self) -> Option<&LazyAttrTokenStream> {
211211
match self {
212-
Nonterminal::NtExpr(expr) | Nonterminal::NtLiteral(expr) => expr.tokens(),
213212
Nonterminal::NtBlock(block) => block.tokens(),
214213
}
215214
}
216215
fn tokens_mut(&mut self) -> Option<&mut Option<LazyAttrTokenStream>> {
217216
match self {
218-
Nonterminal::NtExpr(expr) | Nonterminal::NtLiteral(expr) => expr.tokens_mut(),
219217
Nonterminal::NtBlock(block) => block.tokens_mut(),
220218
}
221219
}

‎compiler/rustc_ast/src/mut_visit.rs‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -900,8 +900,6 @@ pub fn visit_token<T: MutVisitor>(vis: &mut T, t: &mut Token) {
900900
fn visit_nonterminal<T: MutVisitor>(vis: &mut T, nt: &mut token::Nonterminal) {
901901
match nt {
902902
token::NtBlock(block) => vis.visit_block(block),
903-
token::NtExpr(expr) => vis.visit_expr(expr),
904-
token::NtLiteral(expr) => vis.visit_expr(expr),
905903
}
906904
}
907905

‎compiler/rustc_ast/src/token.rs‎

Lines changed: 23 additions & 48 deletions
Original file line numberDiff line numberDiff line change
@@ -198,16 +198,17 @@ impl Lit {
198198
}
199199
}
200200

201-
/// Keep this in sync with `Token::can_begin_literal_maybe_minus` excluding unary negation.
201+
/// Keep this in sync with `Token::can_begin_literal_maybe_minus` and
202+
/// `Parser::eat_token_lit` (excluding unary negation).
202203
pub fn from_token(token: &Token) -> Option<Lit> {
203204
match token.uninterpolate().kind {
204205
Ident(name, IdentIsRaw::No) if name.is_bool_lit() => Some(Lit::new(Bool, name, None)),
205206
Literal(token_lit) => Some(token_lit),
206-
Interpolated(ref nt)
207-
ifletNtExpr(expr) | NtLiteral(expr) = &**nt
208-
&& let ast::ExprKind::Lit(token_lit) = expr.kind =>
209-
{
210-
Some(token_lit)
207+
OpenDelim(Delimiter::Invisible(InvisibleOrigin::MetaVar(
208+
MetaVarKind::Literal | MetaVarKind::Expr{ .. },
209+
))) => {
210+
// Unreachable with the current test suite.
211+
panic!("from_token metavar");
211212
}
212213
_ => None,
213214
}
@@ -590,6 +591,9 @@ impl Token {
590591
/// for which spans affect name resolution and edition checks.
591592
/// Note that keywords are also identifiers, so they should use this
592593
/// if they keep spans or perform edition checks.
594+
//
595+
// Note: `Parser::uninterpolated_token_span` may give better information
596+
// than this method does.
593597
pub fn uninterpolated_span(&self) -> Span {
594598
match self.kind {
595599
NtIdent(ident, _) | NtLifetime(ident, _) => ident.span,
@@ -642,12 +646,7 @@ impl Token {
642646
PathSep | // global path
643647
Lifetime(..) | // labeled loop
644648
Pound => true, // expression attributes
645-
Interpolated(ref nt) =>
646-
matches!(&**nt,
647-
NtBlock(..) |
648-
NtExpr(..) |
649-
NtLiteral(..)
650-
),
649+
Interpolated(ref nt) => matches!(&**nt, NtBlock(..)),
651650
OpenDelim(Delimiter::Invisible(InvisibleOrigin::MetaVar(
652651
MetaVarKind::Block |
653652
MetaVarKind::Expr { .. } |
@@ -677,11 +676,6 @@ impl Token {
677676
Lt | // path (UFCS constant)
678677
Shl => true, // path (double UFCS)
679678
Or => matches!(pat_kind, PatWithOr), // leading vert `|` or-pattern
680-
Interpolated(nt) =>
681-
matches!(&**nt,
682-
| NtExpr(..)
683-
| NtLiteral(..)
684-
),
685679
OpenDelim(Delimiter::Invisible(InvisibleOrigin::MetaVar(
686680
MetaVarKind::Expr { .. } |
687681
MetaVarKind::Literal |
@@ -724,7 +718,7 @@ impl Token {
724718
match self.kind {
725719
OpenDelim(Delimiter::Brace) | Literal(..) | Minus => true,
726720
Ident(name, IdentIsRaw::No) if name.is_bool_lit() => true,
727-
Interpolated(ref nt) => matches!(&**nt, NtExpr(..) | NtBlock(..) | NtLiteral(..)),
721+
Interpolated(ref nt) => matches!(&**nt, NtBlock(..)),
728722
OpenDelim(Delimiter::Invisible(InvisibleOrigin::MetaVar(
729723
MetaVarKind::Expr { .. } | MetaVarKind::Block | MetaVarKind::Literal,
730724
))) => true,
@@ -768,22 +762,12 @@ impl Token {
768762
///
769763
/// In other words, would this token be a valid start of `parse_literal_maybe_minus`?
770764
///
771-
/// Keep this in sync with and `Lit::from_token`, excluding unary negation.
765+
/// Keep this in sync with `Lit::from_token` and `Parser::eat_token_lit`
766+
/// (excluding unary negation).
772767
pub fn can_begin_literal_maybe_minus(&self) -> bool {
773768
match self.uninterpolate().kind {
774769
Literal(..) | Minus => true,
775770
Ident(name, IdentIsRaw::No) if name.is_bool_lit() => true,
776-
Interpolated(ref nt) => match &**nt {
777-
NtLiteral(_) => true,
778-
NtExpr(e) => match &e.kind {
779-
ast::ExprKind::Lit(_) => true,
780-
ast::ExprKind::Unary(ast::UnOp::Neg, e) => {
781-
matches!(&e.kind, ast::ExprKind::Lit(_))
782-
}
783-
_ => false,
784-
},
785-
_ => false,
786-
},
787771
OpenDelim(Delimiter::Invisible(InvisibleOrigin::MetaVar(mv_kind))) => match mv_kind {
788772
MetaVarKind::Literal => true,
789773
MetaVarKind::Expr { can_begin_literal_maybe_minus, .. } => {
@@ -798,14 +782,6 @@ impl Token {
798782
pub fn can_begin_string_literal(&self) -> bool {
799783
match self.uninterpolate().kind {
800784
Literal(..) => true,
801-
Interpolated(ref nt) => match &**nt {
802-
NtLiteral(_) => true,
803-
NtExpr(e) => match &e.kind {
804-
ast::ExprKind::Lit(_) => true,
805-
_ => false,
806-
},
807-
_ => false,
808-
},
809785
OpenDelim(Delimiter::Invisible(InvisibleOrigin::MetaVar(mv_kind))) => match mv_kind {
810786
MetaVarKind::Literal => true,
811787
MetaVarKind::Expr { can_begin_string_literal, .. } => can_begin_string_literal,
@@ -869,19 +845,25 @@ impl Token {
869845

870846
/// Is this a pre-parsed expression dropped into the token stream
871847
/// (which happens while parsing the result of macro expansion)?
872-
pub fn is_whole_expr(&self) -> bool {
848+
pub fn is_metavar_expr(&self) -> bool {
873849
#[allow(irrefutable_let_patterns)] // FIXME: temporary
874850
if let Interpolated(nt) = &self.kind
875-
&& let NtExpr(_) | NtLiteral(_) | NtBlock(_) = &**nt
851+
&& let NtBlock(_) = &**nt
876852
{
877853
true
854+
} else if matches!(
855+
self.is_metavar_seq(),
856+
Some(MetaVarKind::Expr { .. } | MetaVarKind::Literal | MetaVarKind::Path)
857+
) {
858+
true
878859
} else {
879860
matches!(self.is_metavar_seq(), Some(MetaVarKind::Path))
880861
}
881862
}
882863

883864
/// Is the token an interpolated block (`$b:block`)?
884865
pub fn is_whole_block(&self) -> bool {
866+
#[allow(irrefutable_let_patterns)] // FIXME: temporary
885867
if let Interpolated(nt) = &self.kind
886868
&& let NtBlock(..) = &**nt
887869
{
@@ -1105,8 +1087,6 @@ pub enum NtExprKind {
11051087
/// For interpolation during macro expansion.
11061088
pub enum Nonterminal {
11071089
NtBlock(P<ast::Block>),
1108-
NtExpr(P<ast::Expr>),
1109-
NtLiteral(P<ast::Expr>),
11101090
}
11111091

11121092
#[derive(Debug, Copy, Clone, PartialEq, Eq, Encodable, Decodable, Hash, HashStable_Generic)]
@@ -1196,15 +1176,12 @@ impl Nonterminal {
11961176
pub fn use_span(&self) -> Span {
11971177
match self {
11981178
NtBlock(block) => block.span,
1199-
NtExpr(expr) | NtLiteral(expr) => expr.span,
12001179
}
12011180
}
12021181

12031182
pub fn descr(&self) -> &'static str {
12041183
match self {
12051184
NtBlock(..) => "block",
1206-
NtExpr(..) => "expression",
1207-
NtLiteral(..) => "literal",
12081185
}
12091186
}
12101187
}
@@ -1223,8 +1200,6 @@ impl fmt::Debug for Nonterminal {
12231200
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
12241201
match *self {
12251202
NtBlock(..) => f.pad("NtBlock(..)"),
1226-
NtExpr(..) => f.pad("NtExpr(..)"),
1227-
NtLiteral(..) => f.pad("NtLiteral(..)"),
12281203
}
12291204
}
12301205
}
@@ -1247,7 +1222,7 @@ mod size_asserts {
12471222
// tidy-alphabetical-start
12481223
static_assert_size!(Lit, 12);
12491224
static_assert_size!(LitKind, 2);
1250-
static_assert_size!(Nonterminal, 16);
1225+
static_assert_size!(Nonterminal, 8);
12511226
static_assert_size!(Token, 24);
12521227
static_assert_size!(TokenKind, 16);
12531228
// tidy-alphabetical-end

‎compiler/rustc_ast/src/tokenstream.rs‎

Lines changed: 39 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -233,35 +233,52 @@ fn attrs_and_tokens_to_token_trees(
233233

234234
// Insert inner attribute tokens.
235235
if !inner_attrs.is_empty() {
236-
let mut found = false;
237-
// Check the last two trees (to account for a trailing semi)
238-
for tree in res.iter_mut().rev().take(2) {
239-
if let TokenTree::Delimited(span, spacing, delim, delim_tokens) = tree {
240-
// Inner attributes are only supported on extern blocks, functions,
241-
// impls, and modules. All of these have their inner attributes
242-
// placed at the beginning of the rightmost outermost braced group:
243-
// e.g. fn foo() { #![my_attr] }
244-
//
245-
// Therefore, we can insert them back into the right location
246-
// without needing to do any extra position tracking.
247-
//
248-
// Note: Outline modules are an exception - they can
249-
// have attributes like `#![my_attr]` at the start of a file.
250-
// Support for custom attributes in this position is not
251-
// properly implemented - we always synthesize fake tokens,
252-
// so we never reach this code.
236+
let found = insert_inner_attrs(inner_attrs, res);
237+
assert!(found, "Failed to find trailing delimited group in: {res:?}");
238+
}
239+
240+
// Inner attributes are only supported on blocks, functions, impls, and
241+
// modules. All of these have their inner attributes placed at the
242+
// beginning of the rightmost outermost braced group:
243+
// e.g. `fn foo() { #![my_attr] }`. (Note: the braces may be within
244+
// invisible delimiters.)
245+
//
246+
// Therefore, we can insert them back into the right location without
247+
// needing to do any extra position tracking.
248+
//
249+
// Note: Outline modules are an exception - they can have attributes like
250+
// `#![my_attr]` at the start of a file. Support for custom attributes in
251+
// this position is not properly implemented - we always synthesize fake
252+
// tokens, so we never reach this code.
253+
fn insert_inner_attrs(inner_attrs: &[Attribute], tts: &mut Vec<TokenTree>) -> bool {
254+
for tree in tts.iter_mut().rev() {
255+
if let TokenTree::Delimited(span, spacing, Delimiter::Brace, stream) = tree {
256+
// Found it: the rightmost, outermost braced group.
253257
let mut tts = vec![];
254258
for inner_attr in inner_attrs {
255259
tts.extend(inner_attr.token_trees());
256260
}
257-
tts.extend(delim_tokens.0.iter().cloned());
261+
tts.extend(stream.0.iter().cloned());
258262
let stream = TokenStream::new(tts);
259-
*tree = TokenTree::Delimited(*span, *spacing, *delim, stream);
260-
found = true;
261-
break;
263+
*tree = TokenTree::Delimited(*span, *spacing, Delimiter::Brace, stream);
264+
return true;
265+
} else if let TokenTree::Delimited(span, spacing, Delimiter::Invisible(src), stream) =
266+
tree
267+
{
268+
// Recurse inside invisible delimiters.
269+
let mut vec: Vec<_> = stream.iter().cloned().collect();
270+
if insert_inner_attrs(inner_attrs, &mut vec) {
271+
*tree = TokenTree::Delimited(
272+
*span,
273+
*spacing,
274+
Delimiter::Invisible(*src),
275+
TokenStream::new(vec),
276+
);
277+
return true;
278+
}
262279
}
263280
}
264-
assert!(found,"Failed to find trailing delimited group in: {res:?}");
281+
false
265282
}
266283
}
267284

@@ -462,7 +479,6 @@ impl TokenStream {
462479
pub fn from_nonterminal_ast(nt: &Nonterminal) -> TokenStream {
463480
match nt {
464481
Nonterminal::NtBlock(block) => TokenStream::from_ast(block),
465-
Nonterminal::NtExpr(expr) | Nonterminal::NtLiteral(expr) => TokenStream::from_ast(expr),
466482
}
467483
}
468484

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

Lines changed: 28 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -3,11 +3,10 @@ use std::sync::Arc;
33

44
use rustc_ast::mut_visit::{self, MutVisitor};
55
use rustc_ast::token::{
6-
self, Delimiter, IdentIsRaw, InvisibleOrigin, Lit, LitKind, MetaVarKind, Nonterminal, Token,
7-
TokenKind,
6+
self, Delimiter, IdentIsRaw, InvisibleOrigin, Lit, LitKind, MetaVarKind, Token, TokenKind,
87
};
98
use rustc_ast::tokenstream::{DelimSpacing, DelimSpan, Spacing, TokenStream, TokenTree};
10-
use rustc_ast::{ExprKind, StmtKind, TyKind};
9+
use rustc_ast::{ExprKind, StmtKind, TyKind,UnOp};
1110
use rustc_data_structures::fx::FxHashMap;
1211
use rustc_errors::{Diag, DiagCtxtHandle, PResult, pluralize};
1312
use rustc_parse::lexer::nfc_normalize;
@@ -340,6 +339,30 @@ pub(super) fn transcribe<'a>(
340339
MetaVarKind::Pat(*pat_kind),
341340
TokenStream::from_ast(pat),
342341
),
342+
MatchedSingle(ParseNtResult::Expr(expr, kind)) => {
343+
let (can_begin_literal_maybe_minus, can_begin_string_literal) =
344+
match &expr.kind {
345+
ExprKind::Lit(_) => (true, true),
346+
ExprKind::Unary(UnOp::Neg, e)
347+
if matches!(&e.kind, ExprKind::Lit(_)) =>
348+
{
349+
(true, false)
350+
}
351+
_ => (false, false),
352+
};
353+
mk_delimited(
354+
expr.span,
355+
MetaVarKind::Expr {
356+
kind: *kind,
357+
can_begin_literal_maybe_minus,
358+
can_begin_string_literal,
359+
},
360+
TokenStream::from_ast(expr),
361+
)
362+
}
363+
MatchedSingle(ParseNtResult::Literal(lit)) => {
364+
mk_delimited(lit.span, MetaVarKind::Literal, TokenStream::from_ast(lit))
365+
}
343366
MatchedSingle(ParseNtResult::Ty(ty)) => {
344367
let is_path = matches!(&ty.kind, TyKind::Path(None, _path));
345368
mk_delimited(
@@ -869,10 +892,8 @@ fn extract_symbol_from_pnr<'a>(
869892
},
870893
_,
871894
)) => Ok(*symbol),
872-
ParseNtResult::Nt(nt)
873-
if let Nonterminal::NtLiteral(expr) = &**nt
874-
&& let ExprKind::Lit(Lit { kind: LitKind::Str, symbol, suffix: None }) =
875-
&expr.kind =>
895+
ParseNtResult::Literal(expr)
896+
if let ExprKind::Lit(Lit { kind: LitKind::Str, symbol, suffix: None }) = &expr.kind =>
876897
{
877898
Ok(*symbol)
878899
}

‎compiler/rustc_parse/messages.ftl‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -864,7 +864,7 @@ parse_unexpected_parentheses_in_match_arm_pattern = unexpected parentheses surro
864864
parse_unexpected_self_in_generic_parameters = unexpected keyword `Self` in generic parameters
865865
.note = you cannot use `Self` as a generic parameter because it is reserved for associated items
866866
867-
parse_unexpected_token_after_dot = unexpected token: `{$actual}`
867+
parse_unexpected_token_after_dot = unexpected token: {$actual}
868868
869869
parse_unexpected_token_after_label = expected `while`, `for`, `loop` or `{"{"}` after a label
870870
.suggestion_remove_label = consider removing the label

‎compiler/rustc_parse/src/errors.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1714,10 +1714,10 @@ pub(crate) struct SelfArgumentPointer {
17141714

17151715
#[derive(Diagnostic)]
17161716
#[diag(parse_unexpected_token_after_dot)]
1717-
pub(crate) struct UnexpectedTokenAfterDot<'a> {
1717+
pub(crate) struct UnexpectedTokenAfterDot {
17181718
#[primary_span]
17191719
pub span: Span,
1720-
pub actual: Cow<'a,str>,
1720+
pub actual: String,
17211721
}
17221722

17231723
#[derive(Diagnostic)]

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /