Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit 3828fa2

Browse files
CentrilCentril
authoredFeb 28, 2020
Rollup merge of #69384 - petrochenkov:nounnorm, r=Centril
parser: `token` -> `normalized_token`, `nonnormalized_token` -> `token` So, after #69006, its follow-ups and an attempt to remove `Parser::prev_span` I came to the conclusion that the unnormalized token and its span is what you want in most cases, so it should be default. Normalization only makes difference in few cases where we are checking against `token::Ident` or `token::Lifetime` specifically. This PR uses `normalized_token` for those cases. Using normalization explicitly means that people writing code should remember about `NtIdent` and `NtLifetime` in general. (That is alleviated by the fact that `token.ident()` and `fn parse_ident_*` are already written.) Remembering about `NtIdent`, was, however, already the case, kind of, because the implicit normalization was performed only for the current/previous token, but not for things like `look_ahead`. As a result, most of token classification methods in `token.rs` already take `NtIdent` into account (this PR fixes a few pre-existing minor mistakes though). The next step is removing `normalized(_prev)_token` entirely and replacing it with `token.ident()` (mostly) and `token.normalize()` (occasionally). I want to make it a separate PR for that and run it though perf. `normalized_token` filled on every bump has both a potential to avoid repeated normalization, and to do unnecessary work in advance (it probably doesn't matter anyway, the normalization is very cheap). r? @Centril
2 parents 76fe449 + b2605c1 commit 3828fa2

File tree

16 files changed

+132
-125
lines changed

16 files changed

+132
-125
lines changed
 

‎src/librustc_builtin_macros/format.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -158,7 +158,7 @@ fn parse_args<'a>(
158158
} // accept trailing commas
159159
if p.token.is_ident() && p.look_ahead(1, |t| *t == token::Eq) {
160160
named = true;
161-
let name = if let token::Ident(name, _) = p.token.kind {
161+
let name = if let token::Ident(name, _) = p.normalized_token.kind {
162162
p.bump();
163163
name
164164
} else {

‎src/librustc_expand/mbe/macro_parser.rs

Lines changed: 7 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -753,6 +753,12 @@ pub(super) fn parse_tt(parser: &mut Cow<'_, Parser<'_>>, ms: &[TokenTree]) -> Na
753753
fn get_macro_name(token: &Token) -> Option<(Name, bool)> {
754754
match token.kind {
755755
token::Ident(name, is_raw) if name != kw::Underscore => Some((name, is_raw)),
756+
token::Interpolated(ref nt) => match **nt {
757+
token::NtIdent(ident, is_raw) if ident.name != kw::Underscore => {
758+
Some((ident.name, is_raw))
759+
}
760+
_ => None,
761+
},
756762
_ => None,
757763
}
758764
}
@@ -883,9 +889,8 @@ fn parse_nt_inner<'a>(p: &mut Parser<'a>, sp: Span, name: Symbol) -> PResult<'a,
883889
// this could be handled like a token, since it is one
884890
sym::ident => {
885891
if let Some((name, is_raw)) = get_macro_name(&p.token) {
886-
let span = p.token.span;
887892
p.bump();
888-
token::NtIdent(Ident::new(name, span), is_raw)
893+
token::NtIdent(Ident::new(name, p.normalized_prev_token.span), is_raw)
889894
} else {
890895
let token_str = pprust::token_to_string(&p.token);
891896
let msg = &format!("expected ident, found {}", &token_str);

‎src/librustc_parse/parser/diagnostics.rs

Lines changed: 6 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ use syntax::ast::{
1313
};
1414
use syntax::ast::{AttrVec, ItemKind, Mutability, Pat, PatKind, PathSegment, QSelf, Ty, TyKind};
1515
use syntax::ptr::P;
16-
use syntax::token::{self, token_can_begin_expr, TokenKind};
16+
use syntax::token::{self, TokenKind};
1717
use syntax::util::parser::AssocOp;
1818

1919
use log::{debug, trace};
@@ -192,12 +192,12 @@ impl<'a> Parser<'a> {
192192
TokenKind::CloseDelim(token::DelimToken::Brace),
193193
TokenKind::CloseDelim(token::DelimToken::Paren),
194194
];
195-
if let token::Ident(name, false) = self.token.kind {
196-
if Ident::new(name, self.token.span).is_raw_guess()
195+
if let token::Ident(name, false) = self.normalized_token.kind {
196+
if Ident::new(name, self.normalized_token.span).is_raw_guess()
197197
&& self.look_ahead(1, |t| valid_follow.contains(&t.kind))
198198
{
199199
err.span_suggestion(
200-
self.token.span,
200+
self.normalized_token.span,
201201
"you can escape reserved keywords to use them as identifiers",
202202
format!("r#{}", name),
203203
Applicability::MaybeIncorrect,
@@ -900,8 +900,7 @@ impl<'a> Parser<'a> {
900900
} else if !sm.is_multiline(self.prev_span.until(self.token.span)) {
901901
// The current token is in the same line as the prior token, not recoverable.
902902
} else if self.look_ahead(1, |t| {
903-
t == &token::CloseDelim(token::Brace)
904-
|| token_can_begin_expr(t) && t.kind != token::Colon
903+
t == &token::CloseDelim(token::Brace) || t.can_begin_expr() && t.kind != token::Colon
905904
}) && [token::Comma, token::Colon].contains(&self.token.kind)
906905
{
907906
// Likely typo: `,` → `;` or `:` → `;`. This is triggered if the current token is
@@ -919,7 +918,7 @@ impl<'a> Parser<'a> {
919918
} else if self.look_ahead(0, |t| {
920919
t == &token::CloseDelim(token::Brace)
921920
|| (
922-
token_can_begin_expr(t) && t != &token::Semi && t != &token::Pound
921+
t.can_begin_expr() && t != &token::Semi && t != &token::Pound
923922
// Avoid triggering with too many trailing `#` in raw string.
924923
)
925924
}) {

‎src/librustc_parse/parser/expr.rs

Lines changed: 18 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -97,15 +97,14 @@ impl<'a> Parser<'a> {
9797
fn parse_expr_catch_underscore(&mut self) -> PResult<'a, P<Expr>> {
9898
match self.parse_expr() {
9999
Ok(expr) => Ok(expr),
100-
Err(mut err) => match self.token.kind {
100+
Err(mut err) => match self.normalized_token.kind {
101101
token::Ident(name, false)
102102
if name == kw::Underscore && self.look_ahead(1, |t| t == &token::Comma) =>
103103
{
104104
// Special-case handling of `foo(_, _, _)`
105105
err.emit();
106-
let sp = self.token.span;
107106
self.bump();
108-
Ok(self.mk_expr(sp, ExprKind::Err, AttrVec::new()))
107+
Ok(self.mk_expr(self.prev_token.span, ExprKind::Err, AttrVec::new()))
109108
}
110109
_ => Err(err),
111110
},
@@ -166,7 +165,7 @@ impl<'a> Parser<'a> {
166165
while let Some(op) = self.check_assoc_op() {
167166
// Adjust the span for interpolated LHS to point to the `$lhs` token
168167
// and not to what it refers to.
169-
let lhs_span = match self.unnormalized_prev_token.kind {
168+
let lhs_span = match self.prev_token.kind {
170169
TokenKind::Interpolated(..) => self.prev_span,
171170
_ => lhs.span,
172171
};
@@ -333,7 +332,7 @@ impl<'a> Parser<'a> {
333332
/// Also performs recovery for `and` / `or` which are mistaken for `&&` and `||` respectively.
334333
fn check_assoc_op(&self) -> Option<Spanned<AssocOp>> {
335334
Some(Spanned {
336-
node: match (AssocOp::from_token(&self.token), &self.token.kind) {
335+
node: match (AssocOp::from_token(&self.token), &self.normalized_token.kind) {
337336
(Some(op), _) => op,
338337
(None, token::Ident(sym::and, false)) => {
339338
self.error_bad_logical_op("and", "&&", "conjunction");
@@ -345,7 +344,7 @@ impl<'a> Parser<'a> {
345344
}
346345
_ => return None,
347346
},
348-
span: self.token.span,
347+
span: self.normalized_token.span,
349348
})
350349
}
351350

@@ -437,7 +436,7 @@ impl<'a> Parser<'a> {
437436
let attrs = self.parse_or_use_outer_attributes(attrs)?;
438437
let lo = self.token.span;
439438
// Note: when adding new unary operators, don't forget to adjust TokenKind::can_begin_expr()
440-
let (hi, ex) = match self.token.kind {
439+
let (hi, ex) = match self.normalized_token.kind {
441440
token::Not => self.parse_unary_expr(lo, UnOp::Not), // `!expr`
442441
token::Tilde => self.recover_tilde_expr(lo), // `~expr`
443442
token::BinOp(token::Minus) => self.parse_unary_expr(lo, UnOp::Neg), // `-expr`
@@ -523,7 +522,7 @@ impl<'a> Parser<'a> {
523522
) -> PResult<'a, (Span, P<Expr>)> {
524523
expr.map(|e| {
525524
(
526-
match self.unnormalized_prev_token.kind {
525+
match self.prev_token.kind {
527526
TokenKind::Interpolated(..) => self.prev_span,
528527
_ => e.span,
529528
},
@@ -704,7 +703,7 @@ impl<'a> Parser<'a> {
704703
}
705704

706705
fn parse_dot_suffix_expr(&mut self, lo: Span, base: P<Expr>) -> PResult<'a, P<Expr>> {
707-
match self.token.kind {
706+
match self.normalized_token.kind {
708707
token::Ident(..) => self.parse_dot_suffix(base, lo),
709708
token::Literal(token::Lit { kind: token::Integer, symbol, suffix }) => {
710709
Ok(self.parse_tuple_field_access_expr(lo, base, symbol, suffix))
@@ -773,8 +772,8 @@ impl<'a> Parser<'a> {
773772
field: Symbol,
774773
suffix: Option<Symbol>,
775774
) -> P<Expr> {
776-
let span = self.token.span;
777775
self.bump();
776+
let span = self.prev_token.span;
778777
let field = ExprKind::Field(base, Ident::new(field, span));
779778
self.expect_no_suffix(span, "a tuple index", suffix);
780779
self.mk_expr(lo.to(span), field, AttrVec::new())
@@ -798,7 +797,7 @@ impl<'a> Parser<'a> {
798797

799798
/// Assuming we have just parsed `.`, continue parsing into an expression.
800799
fn parse_dot_suffix(&mut self, self_arg: P<Expr>, lo: Span) -> PResult<'a, P<Expr>> {
801-
if self.token.span.rust_2018() && self.eat_keyword(kw::Await) {
800+
if self.normalized_token.span.rust_2018() && self.eat_keyword(kw::Await) {
802801
return self.mk_await_expr(self_arg, lo);
803802
}
804803

@@ -912,7 +911,7 @@ impl<'a> Parser<'a> {
912911
// | ^ expected expression
913912
self.bump();
914913
Ok(self.mk_expr_err(self.token.span))
915-
} else if self.token.span.rust_2018() {
914+
} else if self.normalized_token.span.rust_2018() {
916915
// `Span::rust_2018()` is somewhat expensive; don't get it repeatedly.
917916
if self.check_keyword(kw::Async) {
918917
if self.is_async_block() {
@@ -1342,7 +1341,7 @@ impl<'a> Parser<'a> {
13421341
if self.eat_keyword(kw::Static) { Movability::Static } else { Movability::Movable };
13431342

13441343
let asyncness =
1345-
if self.token.span.rust_2018() { self.parse_asyncness() } else { Async::No };
1344+
if self.normalized_token.span.rust_2018() { self.parse_asyncness() } else { Async::No };
13461345
if asyncness.is_async() {
13471346
// Feature-gate `async ||` closures.
13481347
self.sess.gated_spans.gate(sym::async_closure, self.prev_span);
@@ -1556,9 +1555,8 @@ impl<'a> Parser<'a> {
15561555

15571556
fn eat_label(&mut self) -> Option<Label> {
15581557
self.token.lifetime().map(|ident| {
1559-
let span = self.token.span;
15601558
self.bump();
1561-
Label { ident: Ident::new(ident.name, span) }
1559+
Label { ident }
15621560
})
15631561
}
15641562

@@ -1700,7 +1698,7 @@ impl<'a> Parser<'a> {
17001698
fn is_try_block(&self) -> bool {
17011699
self.token.is_keyword(kw::Try) &&
17021700
self.look_ahead(1, |t| *t == token::OpenDelim(token::Brace)) &&
1703-
self.token.span.rust_2018() &&
1701+
self.normalized_token.span.rust_2018() &&
17041702
// Prevent `while try {} {}`, `if try {} {} else {}`, etc.
17051703
!self.restrictions.contains(Restrictions::NO_STRUCT_LITERAL)
17061704
}
@@ -1850,13 +1848,12 @@ impl<'a> Parser<'a> {
18501848

18511849
/// Use in case of error after field-looking code: `S { foo: () with a }`.
18521850
fn find_struct_error_after_field_looking_code(&self) -> Option<Field> {
1853-
if let token::Ident(name, _) = self.token.kind {
1851+
if let token::Ident(name, _) = self.normalized_token.kind {
18541852
if !self.token.is_reserved_ident() && self.look_ahead(1, |t| *t == token::Colon) {
1855-
let span = self.token.span;
18561853
return Some(ast::Field {
1857-
ident: Ident::new(name, span),
1858-
span,
1859-
expr: self.mk_expr_err(span),
1854+
ident: Ident::new(name, self.normalized_token.span),
1855+
span: self.token.span,
1856+
expr: self.mk_expr_err(self.token.span),
18601857
is_shorthand: false,
18611858
attrs: AttrVec::new(),
18621859
id: DUMMY_NODE_ID,

‎src/librustc_parse/parser/item.rs

Lines changed: 6 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -741,11 +741,10 @@ impl<'a> Parser<'a> {
741741
}
742742

743743
fn parse_ident_or_underscore(&mut self) -> PResult<'a, ast::Ident> {
744-
match self.token.kind {
744+
match self.normalized_token.kind {
745745
token::Ident(name @ kw::Underscore, false) => {
746-
let span = self.token.span;
747746
self.bump();
748-
Ok(Ident::new(name, span))
747+
Ok(Ident::new(name, self.normalized_prev_token.span))
749748
}
750749
_ => self.parse_ident(),
751750
}
@@ -1537,7 +1536,7 @@ impl<'a> Parser<'a> {
15371536

15381537
let is_name_required = match self.token.kind {
15391538
token::DotDotDot => false,
1540-
_ => req_name(&self.token),
1539+
_ => req_name(&self.normalized_token),
15411540
};
15421541
let (pat, ty) = if is_name_required || self.is_named_param() {
15431542
debug!("parse_param_general parse_pat (is_name_required:{})", is_name_required);
@@ -1603,12 +1602,11 @@ impl<'a> Parser<'a> {
16031602
fn parse_self_param(&mut self) -> PResult<'a, Option<Param>> {
16041603
// Extract an identifier *after* having confirmed that the token is one.
16051604
let expect_self_ident = |this: &mut Self| {
1606-
match this.token.kind {
1605+
match this.normalized_token.kind {
16071606
// Preserve hygienic context.
16081607
token::Ident(name, _) => {
1609-
let span = this.token.span;
16101608
this.bump();
1611-
Ident::new(name, span)
1609+
Ident::new(name, this.normalized_prev_token.span)
16121610
}
16131611
_ => unreachable!(),
16141612
}
@@ -1645,7 +1643,7 @@ impl<'a> Parser<'a> {
16451643
// Only a limited set of initial token sequences is considered `self` parameters; anything
16461644
// else is parsed as a normal function parameter list, so some lookahead is required.
16471645
let eself_lo = self.token.span;
1648-
let (eself, eself_ident, eself_hi) = match self.token.kind {
1646+
let (eself, eself_ident, eself_hi) = match self.normalized_token.kind {
16491647
token::BinOp(token::And) => {
16501648
let eself = if is_isolated_self(self, 1) {
16511649
// `&self`

‎src/librustc_parse/parser/mod.rs

Lines changed: 23 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -86,23 +86,22 @@ macro_rules! maybe_recover_from_interpolated_ty_qpath {
8686
#[derive(Clone)]
8787
pub struct Parser<'a> {
8888
pub sess: &'a ParseSess,
89+
/// The current non-normalized token.
90+
pub token: Token,
8991
/// The current normalized token.
9092
/// "Normalized" means that some interpolated tokens
9193
/// (`$i: ident` and `$l: lifetime` meta-variables) are replaced
9294
/// with non-interpolated identifier and lifetime tokens they refer to.
93-
/// Use span from this token if you need an isolated span.
94-
pub token: Token,
95-
/// The current non-normalized token if it's different from `token`.
96-
/// Use span from this token if you need to concatenate it with some neighbouring spans.
97-
unnormalized_token: Token,
95+
/// Use this if you need to check for `token::Ident` or `token::Lifetime` specifically,
96+
/// this also includes edition checks for edition-specific keyword identifiers.
97+
pub normalized_token: Token,
98+
/// The previous non-normalized token.
99+
pub prev_token: Token,
98100
/// The previous normalized token.
99-
/// Use span from this token if you need an isolated span.
100-
prev_token: Token,
101-
/// The previous non-normalized token if it's different from `prev_token`.
102-
/// Use span from this token if you need to concatenate it with some neighbouring spans.
103-
unnormalized_prev_token: Token,
104-
/// Equivalent to `unnormalized_prev_token.span`.
105-
/// FIXME: Remove in favor of `(unnormalized_)prev_token.span`.
101+
/// Use this if you need to check for `token::Ident` or `token::Lifetime` specifically,
102+
/// this also includes edition checks for edition-specific keyword identifiers.
103+
pub normalized_prev_token: Token,
104+
/// FIXME: Remove in favor of the equivalent `prev_token.span`.
106105
pub prev_span: Span,
107106
restrictions: Restrictions,
108107
/// Used to determine the path to externally loaded source files.
@@ -375,9 +374,9 @@ impl<'a> Parser<'a> {
375374
let mut parser = Parser {
376375
sess,
377376
token: Token::dummy(),
378-
unnormalized_token: Token::dummy(),
377+
normalized_token: Token::dummy(),
379378
prev_token: Token::dummy(),
380-
unnormalized_prev_token: Token::dummy(),
379+
normalized_prev_token: Token::dummy(),
381380
prev_span: DUMMY_SP,
382381
restrictions: Restrictions::empty(),
383382
recurse_into_file_modules,
@@ -482,7 +481,7 @@ impl<'a> Parser<'a> {
482481
}
483482

484483
fn parse_ident_common(&mut self, recover: bool) -> PResult<'a, ast::Ident> {
485-
match self.token.kind {
484+
match self.normalized_token.kind {
486485
token::Ident(name, _) => {
487486
if self.token.is_reserved_ident() {
488487
let mut err = self.expected_ident_found();
@@ -492,9 +491,8 @@ impl<'a> Parser<'a> {
492491
return Err(err);
493492
}
494493
}
495-
let span = self.token.span;
496494
self.bump();
497-
Ok(Ident::new(name, span))
495+
Ok(Ident::new(name, self.normalized_prev_token.span))
498496
}
499497
_ => Err(match self.prev_token.kind {
500498
TokenKind::DocComment(..) => {
@@ -824,16 +822,16 @@ impl<'a> Parser<'a> {
824822
// tokens are replaced with usual identifier and lifetime tokens,
825823
// so the former are never encountered during normal parsing.
826824
crate fn set_token(&mut self, token: Token) {
827-
self.unnormalized_token = token;
828-
self.token = match &self.unnormalized_token.kind {
825+
self.token = token;
826+
self.normalized_token = match &self.token.kind {
829827
token::Interpolated(nt) => match **nt {
830828
token::NtIdent(ident, is_raw) => {
831829
Token::new(token::Ident(ident.name, is_raw), ident.span)
832830
}
833831
token::NtLifetime(ident) => Token::new(token::Lifetime(ident.name), ident.span),
834-
_ => self.unnormalized_token.clone(),
832+
_ => self.token.clone(),
835833
},
836-
_ => self.unnormalized_token.clone(),
834+
_ => self.token.clone(),
837835
}
838836
}
839837

@@ -847,19 +845,19 @@ impl<'a> Parser<'a> {
847845

848846
// Update the current and previous tokens.
849847
self.prev_token = self.token.take();
850-
self.unnormalized_prev_token = self.unnormalized_token.take();
848+
self.normalized_prev_token = self.normalized_token.take();
851849
self.set_token(next_token);
852850

853851
// Update fields derived from the previous token.
854-
self.prev_span = self.unnormalized_prev_token.span;
852+
self.prev_span = self.prev_token.span;
855853

856854
// Diagnostics.
857855
self.expected_tokens.clear();
858856
}
859857

860858
/// Advance the parser by one token.
861859
pub fn bump(&mut self) {
862-
let next_token = self.next_tok(self.unnormalized_token.span);
860+
let next_token = self.next_tok(self.token.span);
863861
self.bump_with(next_token);
864862
}
865863

@@ -890,7 +888,7 @@ impl<'a> Parser<'a> {
890888
/// Parses asyncness: `async` or nothing.
891889
fn parse_asyncness(&mut self) -> Async {
892890
if self.eat_keyword(kw::Async) {
893-
let span = self.prev_span;
891+
let span = self.normalized_prev_token.span;
894892
Async::Yes { span, closure_id: DUMMY_NODE_ID, return_impl_trait_id: DUMMY_NODE_ID }
895893
} else {
896894
Async::No

‎src/librustc_parse/parser/path.rs

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -134,7 +134,7 @@ impl<'a> Parser<'a> {
134134
path
135135
});
136136

137-
let lo = self.unnormalized_token.span;
137+
let lo = self.token.span;
138138
let mut segments = Vec::new();
139139
let mod_sep_ctxt = self.token.span.ctxt();
140140
if self.eat(&token::ModSep) {
@@ -238,11 +238,10 @@ impl<'a> Parser<'a> {
238238
}
239239

240240
pub(super) fn parse_path_segment_ident(&mut self) -> PResult<'a, Ident> {
241-
match self.token.kind {
241+
match self.normalized_token.kind {
242242
token::Ident(name, _) if name.is_path_segment_keyword() => {
243-
let span = self.token.span;
244243
self.bump();
245-
Ok(Ident::new(name, span))
244+
Ok(Ident::new(name, self.normalized_prev_token.span))
246245
}
247246
_ => self.parse_ident(),
248247
}

‎src/librustc_parse/parser/ty.rs

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@ use crate::{maybe_recover_from_interpolated_ty_qpath, maybe_whole};
55
use rustc_errors::{pluralize, struct_span_err, Applicability, PResult};
66
use rustc_span::source_map::Span;
77
use rustc_span::symbol::{kw, sym};
8-
use syntax::ast::{self, BareFnTy, FnRetTy, GenericParam, Ident, Lifetime, MutTy, Ty, TyKind};
8+
use syntax::ast::{self, BareFnTy, FnRetTy, GenericParam, Lifetime, MutTy, Ty, TyKind};
99
use syntax::ast::{
1010
GenericBound, GenericBounds, PolyTraitRef, TraitBoundModifier, TraitObjectSyntax,
1111
};
@@ -323,7 +323,7 @@ impl<'a> Parser<'a> {
323323
/// Is a `dyn B0 + ... + Bn` type allowed here?
324324
fn is_explicit_dyn_type(&mut self) -> bool {
325325
self.check_keyword(kw::Dyn)
326-
&& (self.token.span.rust_2018()
326+
&& (self.normalized_token.span.rust_2018()
327327
|| self.look_ahead(1, |t| {
328328
t.can_begin_bound() && !can_continue_type_after_non_fn_ident(t)
329329
}))
@@ -604,9 +604,8 @@ impl<'a> Parser<'a> {
604604
/// Parses a single lifetime `'a` or panics.
605605
pub fn expect_lifetime(&mut self) -> Lifetime {
606606
if let Some(ident) = self.token.lifetime() {
607-
let span = self.token.span;
608607
self.bump();
609-
Lifetime { ident: Ident::new(ident.name, span), id: ast::DUMMY_NODE_ID }
608+
Lifetime { ident, id: ast::DUMMY_NODE_ID }
610609
} else {
611610
self.span_bug(self.token.span, "not a lifetime")
612611
}

‎src/libsyntax/token.rs

Lines changed: 25 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -147,36 +147,30 @@ impl Lit {
147147

148148
pub fn ident_can_begin_expr(name: ast::Name, span: Span, is_raw: bool) -> bool {
149149
let ident_token = Token::new(Ident(name, is_raw), span);
150-
token_can_begin_expr(&ident_token)
151-
}
152150

153-
pub fn token_can_begin_expr(ident_token: &Token) -> bool {
154151
!ident_token.is_reserved_ident()
155152
|| ident_token.is_path_segment_keyword()
156-
|| match ident_token.kind {
157-
TokenKind::Ident(ident, _) => [
158-
kw::Async,
159-
kw::Do,
160-
kw::Box,
161-
kw::Break,
162-
kw::Continue,
163-
kw::False,
164-
kw::For,
165-
kw::If,
166-
kw::Let,
167-
kw::Loop,
168-
kw::Match,
169-
kw::Move,
170-
kw::Return,
171-
kw::True,
172-
kw::Unsafe,
173-
kw::While,
174-
kw::Yield,
175-
kw::Static,
176-
]
177-
.contains(&ident),
178-
_ => false,
179-
}
153+
|| [
154+
kw::Async,
155+
kw::Do,
156+
kw::Box,
157+
kw::Break,
158+
kw::Continue,
159+
kw::False,
160+
kw::For,
161+
kw::If,
162+
kw::Let,
163+
kw::Loop,
164+
kw::Match,
165+
kw::Move,
166+
kw::Return,
167+
kw::True,
168+
kw::Unsafe,
169+
kw::While,
170+
kw::Yield,
171+
kw::Static,
172+
]
173+
.contains(&name)
180174
}
181175

182176
fn ident_can_begin_type(name: ast::Name, span: Span, is_raw: bool) -> bool {
@@ -369,8 +363,8 @@ impl Token {
369363
Lifetime(..) | // labeled loop
370364
Pound => true, // expression attributes
371365
Interpolated(ref nt) => match **nt {
366+
NtIdent(ident, is_raw) => ident_can_begin_expr(ident.name, ident.span, is_raw),
372367
NtLiteral(..) |
373-
NtIdent(..) |
374368
NtExpr(..) |
375369
NtBlock(..) |
376370
NtPath(..) |
@@ -397,7 +391,8 @@ impl Token {
397391
Lt | BinOp(Shl) | // associated path
398392
ModSep => true, // global path
399393
Interpolated(ref nt) => match **nt {
400-
NtIdent(..) | NtTy(..) | NtPath(..) | NtLifetime(..) => true,
394+
NtIdent(ident, is_raw) => ident_can_begin_type(ident.name, ident.span, is_raw),
395+
NtTy(..) | NtPath(..) | NtLifetime(..) => true,
401396
_ => false,
402397
},
403398
_ => false,
@@ -442,6 +437,7 @@ impl Token {
442437
Literal(..) | BinOp(Minus) => true,
443438
Ident(name, false) if name.is_bool_lit() => true,
444439
Interpolated(ref nt) => match &**nt {
440+
NtIdent(ident, false) if ident.name.is_bool_lit() => true,
445441
NtExpr(e) | NtLiteral(e) => matches!(e.kind, ast::ExprKind::Lit(_)),
446442
_ => false,
447443
},

‎src/libsyntax/util/literal.rs

Lines changed: 10 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -197,10 +197,17 @@ impl Lit {
197197
}
198198
token::Literal(lit) => lit,
199199
token::Interpolated(ref nt) => {
200-
if let token::NtExpr(expr) | token::NtLiteral(expr) = &**nt {
201-
if let ast::ExprKind::Lit(lit) = &expr.kind {
202-
return Ok(lit.clone());
200+
match &**nt {
201+
token::NtIdent(ident, false) if ident.name.is_bool_lit() => {
202+
let lit = token::Lit::new(token::Bool, ident.name, None);
203+
return Lit::from_lit_token(lit, ident.span);
203204
}
205+
token::NtExpr(expr) | token::NtLiteral(expr) => {
206+
if let ast::ExprKind::Lit(lit) = &expr.kind {
207+
return Ok(lit.clone());
208+
}
209+
}
210+
_ => {}
204211
}
205212
return Err(LitError::NotLiteral);
206213
}

‎src/test/ui/borrowck/move-error-snippets.stderr

Lines changed: 11 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,16 @@
11
error[E0507]: cannot move out of static item `D`
2-
--> $DIR/move-error-snippets.rs:16:18
2+
--> $DIR/move-error-snippets-ext.rs:5:17
33
|
4-
LL | | #[macro_use]
5-
| |__________________^ move occurs because `D` has type `A`, which does not implement the `Copy` trait
6-
...
7-
LL | aaa!(D);
8-
| __________________^
9-
...
10-
LL | sss!();
11-
| ------- in this macro invocation
4+
LL | let a = $c;
5+
| ^^
6+
| |
7+
| move occurs because `D` has type `A`, which does not implement the `Copy` trait
8+
| help: consider borrowing here: `&$c`
9+
|
10+
::: $DIR/move-error-snippets.rs:21:1
11+
|
12+
LL | sss!();
13+
| ------- in this macro invocation
1214
|
1315
= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
1416

‎src/test/ui/directory_ownership/macro-expanded-mod.rs

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
// Test that macro-expanded non-inline modules behave correctly
22

33
macro_rules! mod_decl {
4-
($i:ident) => { mod $i; }
4+
($i:ident) => { mod $i; } //~ ERROR Cannot declare a non-inline module inside a block
55
}
66

77
mod macro_expanded_mod_helper {
@@ -10,5 +10,4 @@ mod macro_expanded_mod_helper {
1010

1111
fn main() {
1212
mod_decl!(foo);
13-
//~^ ERROR Cannot declare a non-inline module inside a block
1413
}

‎src/test/ui/directory_ownership/macro-expanded-mod.stderr

Lines changed: 7 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,13 @@
11
error: Cannot declare a non-inline module inside a block unless it has a path attribute
2-
--> $DIR/macro-expanded-mod.rs:12:15
2+
--> $DIR/macro-expanded-mod.rs:4:25
33
|
4+
LL | ($i:ident) => { mod $i; }
5+
| ^^
6+
...
47
LL | mod_decl!(foo);
5-
| ^^^
8+
| --------------- in this macro invocation
9+
|
10+
= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
611

712
error: aborting due to previous error
813

‎src/test/ui/hygiene/fields-definition.stderr

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,10 @@
11
error[E0124]: field `a` is already declared
2-
--> $DIR/fields-definition.rs:14:17
2+
--> $DIR/fields-definition.rs:14:13
33
|
44
LL | a: u8,
55
| ----- `a` first declared here
66
LL | $a: u8,
7-
| ^^ field already declared
7+
| ^^^^^^ field already declared
88
...
99
LL | legacy!(a);
1010
| ----------- in this macro invocation

‎src/test/ui/issues/issue-39848.rs

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,9 @@
11
macro_rules! get_opt {
22
($tgt:expr, $field:ident) => {
3-
if $tgt.has_$field() {}
3+
if $tgt.has_$field() {} //~ ERROR expected `{`, found `foo`
44
}
55
}
66

77
fn main() {
88
get_opt!(bar, foo);
9-
//~^ ERROR expected `{`, found `foo`
109
}

‎src/test/ui/issues/issue-39848.stderr

Lines changed: 8 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,17 @@
11
error: expected `{`, found `foo`
2-
--> $DIR/issue-39848.rs:8:19
2+
--> $DIR/issue-39848.rs:3:21
33
|
44
LL | if $tgt.has_$field() {}
5-
| -- -- help: try placing this code inside a block: `{ () }`
6-
| |
5+
| -- ^^^^^^--
6+
| | |
7+
| | expected `{`
8+
| | help: try placing this code inside a block: `{ $field() }`
79
| this `if` expression has a condition, but no block
810
...
911
LL | get_opt!(bar, foo);
10-
| ^^^ expected `{`
12+
| ------------------- in this macro invocation
13+
|
14+
= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
1115

1216
error: aborting due to previous error
1317

0 commit comments

Comments
 (0)
Please sign in to comment.