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

Commit 26060e6

Browse files
borsbors
committed
Auto merge of rust-lang#133793 - nnethercote:speed-up-expected_tokens, r=<try>
Speed up `Parser::expected_tokens` The constant pushing/clearing of `Parser::expected_tokens` during parsing is slow. This PR speeds it up greatly. r? `@estebank`
2 parents 3b38264 + f5482df commit 26060e6

File tree

22 files changed

+1395
-840
lines changed

22 files changed

+1395
-840
lines changed

‎compiler/rustc_builtin_macros/src/asm.rs‎

Lines changed: 56 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -1,16 +1,16 @@
11
use ast::token::IdentIsRaw;
22
use lint::BuiltinLintDiag;
3-
use rustc_ast::AsmMacro;
43
use rustc_ast::ptr::P;
5-
use rustc_ast::token::{self, Delimiter};
64
use rustc_ast::tokenstream::TokenStream;
5+
use rustc_ast::{AsmMacro, token};
76
use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
87
use rustc_errors::PResult;
98
use rustc_expand::base::*;
109
use rustc_index::bit_set::GrowableBitSet;
11-
use rustc_parse::parser::Parser;
10+
use rustc_parse::exp;
11+
use rustc_parse::parser::{ExpKeywordPair, Parser};
1212
use rustc_session::lint;
13-
use rustc_span::symbol::{Ident, Symbol, kw, sym};
13+
use rustc_span::symbol::{Ident, Symbol, kw};
1414
use rustc_span::{ErrorGuaranteed, InnerSpan, Span};
1515
use rustc_target::asm::InlineAsmArch;
1616
use smallvec::smallvec;
@@ -39,16 +39,16 @@ pub struct AsmArgs {
3939
/// - `Err(_)` if the current token matches the keyword, but was not expected
4040
fn eat_operand_keyword<'a>(
4141
p: &mut Parser<'a>,
42-
symbol: Symbol,
42+
exp: ExpKeywordPair,
4343
asm_macro: AsmMacro,
4444
) -> PResult<'a, bool> {
4545
if matches!(asm_macro, AsmMacro::Asm) {
46-
Ok(p.eat_keyword(symbol))
46+
Ok(p.eat_keyword(exp))
4747
} else {
4848
let span = p.token.span;
49-
if p.eat_keyword_noexpect(symbol) {
49+
if p.eat_keyword_noexpect(exp.kw) {
5050
// in gets printed as `r#in` otherwise
51-
let symbol = if symbol == kw::In { "in" } else { symbol.as_str() };
51+
let symbol = if exp.kw == kw::In { "in" } else { exp.kw.as_str() };
5252
Err(p.dcx().create_err(errors::AsmUnsupportedOperand {
5353
span,
5454
symbol,
@@ -96,28 +96,28 @@ pub fn parse_asm_args<'a>(
9696

9797
let mut allow_templates = true;
9898
while p.token != token::Eof {
99-
if !p.eat(&token::Comma) {
99+
if !p.eat(exp!(Comma)) {
100100
if allow_templates {
101101
// After a template string, we always expect *only* a comma...
102102
return Err(dcx.create_err(errors::AsmExpectedComma { span: p.token.span }));
103103
} else {
104104
// ...after that delegate to `expect` to also include the other expected tokens.
105-
return Err(p.expect(&token::Comma).err().unwrap());
105+
return Err(p.expect(exp!(Comma)).err().unwrap());
106106
}
107107
}
108108
if p.token == token::Eof {
109109
break;
110110
} // accept trailing commas
111111

112112
// Parse clobber_abi
113-
if p.eat_keyword(sym::clobber_abi) {
113+
if p.eat_keyword(exp!(ClobberAbi)) {
114114
parse_clobber_abi(p, &mut args)?;
115115
allow_templates = false;
116116
continue;
117117
}
118118

119119
// Parse options
120-
if p.eat_keyword(sym::options) {
120+
if p.eat_keyword(exp!(Options)) {
121121
parse_options(p, &mut args, asm_macro)?;
122122
allow_templates = false;
123123
continue;
@@ -129,65 +129,65 @@ pub fn parse_asm_args<'a>(
129129
let name = if p.token.is_ident() && p.look_ahead(1, |t| *t == token::Eq) {
130130
let (ident, _) = p.token.ident().unwrap();
131131
p.bump();
132-
p.expect(&token::Eq)?;
132+
p.expect(exp!(Eq))?;
133133
allow_templates = false;
134134
Some(ident.name)
135135
} else {
136136
None
137137
};
138138

139139
let mut explicit_reg = false;
140-
let op = if eat_operand_keyword(p, kw::In, asm_macro)? {
140+
let op = if eat_operand_keyword(p, exp!(In), asm_macro)? {
141141
let reg = parse_reg(p, &mut explicit_reg)?;
142-
if p.eat_keyword(kw::Underscore) {
142+
if p.eat_keyword(exp!(Underscore)) {
143143
let err = dcx.create_err(errors::AsmUnderscoreInput { span: p.token.span });
144144
return Err(err);
145145
}
146146
let expr = p.parse_expr()?;
147147
ast::InlineAsmOperand::In { reg, expr }
148-
} else if eat_operand_keyword(p, sym::out, asm_macro)? {
148+
} else if eat_operand_keyword(p, exp!(Out), asm_macro)? {
149149
let reg = parse_reg(p, &mut explicit_reg)?;
150-
let expr = if p.eat_keyword(kw::Underscore) { None } else { Some(p.parse_expr()?) };
150+
let expr = if p.eat_keyword(exp!(Underscore)) { None } else { Some(p.parse_expr()?) };
151151
ast::InlineAsmOperand::Out { reg, expr, late: false }
152-
} else if eat_operand_keyword(p, sym::lateout, asm_macro)? {
152+
} else if eat_operand_keyword(p, exp!(Lateout), asm_macro)? {
153153
let reg = parse_reg(p, &mut explicit_reg)?;
154-
let expr = if p.eat_keyword(kw::Underscore) { None } else { Some(p.parse_expr()?) };
154+
let expr = if p.eat_keyword(exp!(Underscore)) { None } else { Some(p.parse_expr()?) };
155155
ast::InlineAsmOperand::Out { reg, expr, late: true }
156-
} else if eat_operand_keyword(p, sym::inout, asm_macro)? {
156+
} else if eat_operand_keyword(p, exp!(Inout), asm_macro)? {
157157
let reg = parse_reg(p, &mut explicit_reg)?;
158-
if p.eat_keyword(kw::Underscore) {
158+
if p.eat_keyword(exp!(Underscore)) {
159159
let err = dcx.create_err(errors::AsmUnderscoreInput { span: p.token.span });
160160
return Err(err);
161161
}
162162
let expr = p.parse_expr()?;
163-
if p.eat(&token::FatArrow) {
163+
if p.eat(exp!(FatArrow)) {
164164
let out_expr =
165-
if p.eat_keyword(kw::Underscore) { None } else { Some(p.parse_expr()?) };
165+
if p.eat_keyword(exp!(Underscore)) { None } else { Some(p.parse_expr()?) };
166166
ast::InlineAsmOperand::SplitInOut { reg, in_expr: expr, out_expr, late: false }
167167
} else {
168168
ast::InlineAsmOperand::InOut { reg, expr, late: false }
169169
}
170-
} else if eat_operand_keyword(p, sym::inlateout, asm_macro)? {
170+
} else if eat_operand_keyword(p, exp!(Inlateout), asm_macro)? {
171171
let reg = parse_reg(p, &mut explicit_reg)?;
172-
if p.eat_keyword(kw::Underscore) {
172+
if p.eat_keyword(exp!(Underscore)) {
173173
let err = dcx.create_err(errors::AsmUnderscoreInput { span: p.token.span });
174174
return Err(err);
175175
}
176176
let expr = p.parse_expr()?;
177-
if p.eat(&token::FatArrow) {
177+
if p.eat(exp!(FatArrow)) {
178178
let out_expr =
179-
if p.eat_keyword(kw::Underscore) { None } else { Some(p.parse_expr()?) };
179+
if p.eat_keyword(exp!(Underscore)) { None } else { Some(p.parse_expr()?) };
180180
ast::InlineAsmOperand::SplitInOut { reg, in_expr: expr, out_expr, late: true }
181181
} else {
182182
ast::InlineAsmOperand::InOut { reg, expr, late: true }
183183
}
184-
} else if eat_operand_keyword(p, sym::label, asm_macro)? {
184+
} else if eat_operand_keyword(p, exp!(Label), asm_macro)? {
185185
let block = p.parse_block()?;
186186
ast::InlineAsmOperand::Label { block }
187-
} else if p.eat_keyword(kw::Const) {
187+
} else if p.eat_keyword(exp!(Const)) {
188188
let anon_const = p.parse_expr_anon_const()?;
189189
ast::InlineAsmOperand::Const { anon_const }
190-
} else if p.eat_keyword(sym::sym) {
190+
} else if p.eat_keyword(exp!(Sym)) {
191191
let expr = p.parse_expr()?;
192192
let ast::ExprKind::Path(qself, path) = &expr.kind else {
193193
let err = dcx.create_err(errors::AsmSymNoPath { span: expr.span });
@@ -390,31 +390,31 @@ fn parse_options<'a>(
390390
) -> PResult<'a, ()> {
391391
let span_start = p.prev_token.span;
392392

393-
p.expect(&token::OpenDelim(Delimiter::Parenthesis))?;
394-
395-
while !p.eat(&token::CloseDelim(Delimiter::Parenthesis)) {
396-
const OPTIONS: [(Symbol, ast::InlineAsmOptions); ast::InlineAsmOptions::COUNT] = [
397-
(sym::pure, ast::InlineAsmOptions::PURE),
398-
(sym::nomem, ast::InlineAsmOptions::NOMEM),
399-
(sym::readonly, ast::InlineAsmOptions::READONLY),
400-
(sym::preserves_flags, ast::InlineAsmOptions::PRESERVES_FLAGS),
401-
(sym::noreturn, ast::InlineAsmOptions::NORETURN),
402-
(sym::nostack, ast::InlineAsmOptions::NOSTACK),
403-
(sym::may_unwind, ast::InlineAsmOptions::MAY_UNWIND),
404-
(sym::att_syntax, ast::InlineAsmOptions::ATT_SYNTAX),
405-
(kw::Raw, ast::InlineAsmOptions::RAW),
393+
p.expect(exp!(OpenParen))?;
394+
395+
while !p.eat(exp!(CloseParen)) {
396+
const OPTIONS: [(ExpKeywordPair, ast::InlineAsmOptions); ast::InlineAsmOptions::COUNT] = [
397+
(exp!(Pure), ast::InlineAsmOptions::PURE),
398+
(exp!(Nomem), ast::InlineAsmOptions::NOMEM),
399+
(exp!(Readonly), ast::InlineAsmOptions::READONLY),
400+
(exp!(PreservesFlags), ast::InlineAsmOptions::PRESERVES_FLAGS),
401+
(exp!(Noreturn), ast::InlineAsmOptions::NORETURN),
402+
(exp!(Nostack), ast::InlineAsmOptions::NOSTACK),
403+
(exp!(MayUnwind), ast::InlineAsmOptions::MAY_UNWIND),
404+
(exp!(AttSyntax), ast::InlineAsmOptions::ATT_SYNTAX),
405+
(exp!(Raw), ast::InlineAsmOptions::RAW),
406406
];
407407

408408
'blk: {
409-
for (symbol, option) in OPTIONS {
409+
for (exp, option) in OPTIONS {
410410
let kw_matched = if asm_macro.is_supported_option(option) {
411-
p.eat_keyword(symbol)
411+
p.eat_keyword(exp)
412412
} else {
413-
p.eat_keyword_noexpect(symbol)
413+
p.eat_keyword_noexpect(exp.kw)
414414
};
415415

416416
if kw_matched {
417-
try_set_option(p, args, asm_macro, symbol, option);
417+
try_set_option(p, args, asm_macro, exp.kw, option);
418418
break 'blk;
419419
}
420420
}
@@ -423,10 +423,10 @@ fn parse_options<'a>(
423423
}
424424

425425
// Allow trailing commas
426-
if p.eat(&token::CloseDelim(Delimiter::Parenthesis)) {
426+
if p.eat(exp!(CloseParen)) {
427427
break;
428428
}
429-
p.expect(&token::Comma)?;
429+
p.expect(exp!(Comma))?;
430430
}
431431

432432
let new_span = span_start.to(p.prev_token.span);
@@ -438,14 +438,14 @@ fn parse_options<'a>(
438438
fn parse_clobber_abi<'a>(p: &mut Parser<'a>, args: &mut AsmArgs) -> PResult<'a, ()> {
439439
let span_start = p.prev_token.span;
440440

441-
p.expect(&token::OpenDelim(Delimiter::Parenthesis))?;
441+
p.expect(exp!(OpenParen))?;
442442

443-
if p.eat(&token::CloseDelim(Delimiter::Parenthesis)) {
443+
if p.eat(exp!(CloseParen)) {
444444
return Err(p.dcx().create_err(errors::NonABI { span: p.token.span }));
445445
}
446446

447447
let mut new_abis = Vec::new();
448-
while !p.eat(&token::CloseDelim(Delimiter::Parenthesis)) {
448+
while !p.eat(exp!(CloseParen)) {
449449
match p.parse_str_lit() {
450450
Ok(str_lit) => {
451451
new_abis.push((str_lit.symbol_unescaped, str_lit.span));
@@ -457,10 +457,10 @@ fn parse_clobber_abi<'a>(p: &mut Parser<'a>, args: &mut AsmArgs) -> PResult<'a,
457457
};
458458

459459
// Allow trailing commas
460-
if p.eat(&token::CloseDelim(Delimiter::Parenthesis)) {
460+
if p.eat(exp!(CloseParen)) {
461461
break;
462462
}
463-
p.expect(&token::Comma)?;
463+
p.expect(exp!(Comma))?;
464464
}
465465

466466
let full_span = span_start.to(p.prev_token.span);
@@ -483,7 +483,7 @@ fn parse_reg<'a>(
483483
p: &mut Parser<'a>,
484484
explicit_reg: &mut bool,
485485
) -> PResult<'a, ast::InlineAsmRegOrRegClass> {
486-
p.expect(&token::OpenDelim(Delimiter::Parenthesis))?;
486+
p.expect(exp!(OpenParen))?;
487487
let result = match p.token.uninterpolate().kind {
488488
token::Ident(name, IdentIsRaw::No) => ast::InlineAsmRegOrRegClass::RegClass(name),
489489
token::Literal(token::Lit { kind: token::LitKind::Str, symbol, suffix: _ }) => {
@@ -497,7 +497,7 @@ fn parse_reg<'a>(
497497
}
498498
};
499499
p.bump();
500-
p.expect(&token::CloseDelim(Delimiter::Parenthesis))?;
500+
p.expect(exp!(CloseParen))?;
501501
Ok(result)
502502
}
503503

‎compiler/rustc_builtin_macros/src/assert.rs‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,7 @@ use rustc_ast::{DelimArgs, Expr, ExprKind, MacCall, Path, PathSegment, UnOp, tok
77
use rustc_ast_pretty::pprust;
88
use rustc_errors::PResult;
99
use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacEager, MacroExpanderResult};
10+
use rustc_parse::exp;
1011
use rustc_parse::parser::Parser;
1112
use rustc_span::symbol::{Ident, Symbol, sym};
1213
use rustc_span::{DUMMY_SP, Span};
@@ -144,7 +145,7 @@ fn parse_assert<'a>(cx: &ExtCtxt<'a>, sp: Span, stream: TokenStream) -> PResult<
144145
cx.dcx().emit_err(errors::AssertMissingComma { span: parser.token.span, comma });
145146

146147
parse_custom_message(&mut parser)
147-
} else if parser.eat(&token::Comma) {
148+
} else if parser.eat(exp!(Comma)) {
148149
parse_custom_message(&mut parser)
149150
} else {
150151
None

‎compiler/rustc_builtin_macros/src/cfg.rs‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -6,6 +6,7 @@ use rustc_ast::token;
66
use rustc_ast::tokenstream::TokenStream;
77
use rustc_errors::PResult;
88
use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacEager, MacroExpanderResult};
9+
use rustc_parse::exp;
910
use rustc_span::Span;
1011
use {rustc_ast as ast, rustc_attr as attr};
1112

@@ -48,9 +49,9 @@ fn parse_cfg<'a>(
4849

4950
let cfg = p.parse_meta_item_inner()?;
5051

51-
let _ = p.eat(&token::Comma);
52+
let _ = p.eat(exp!(Comma));
5253

53-
if !p.eat(&token::Eof) {
54+
if !p.eat(exp!(Eof)) {
5455
return Err(cx.dcx().create_err(errors::OneCfgPattern { span }));
5556
}
5657

‎compiler/rustc_builtin_macros/src/format.rs‎

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,7 @@ use rustc_errors::{Applicability, Diag, MultiSpan, PResult, SingleLabelManySpans
1212
use rustc_expand::base::*;
1313
use rustc_lint_defs::builtin::NAMED_ARGUMENTS_USED_POSITIONALLY;
1414
use rustc_lint_defs::{BufferedEarlyLint, BuiltinLintDiag, LintId};
15+
use rustc_parse::exp;
1516
use rustc_parse_format as parse;
1617
use rustc_span::symbol::{Ident, Symbol};
1718
use rustc_span::{BytePos, ErrorGuaranteed, InnerSpan, Span};
@@ -94,12 +95,12 @@ fn parse_args<'a>(ecx: &ExtCtxt<'a>, sp: Span, tts: TokenStream) -> PResult<'a,
9495
let mut first = true;
9596

9697
while p.token != token::Eof {
97-
if !p.eat(&token::Comma) {
98+
if !p.eat(exp!(Comma)) {
9899
if first {
99-
p.clear_expected_tokens();
100+
p.clear_expected_token_types();
100101
}
101102

102-
match p.expect(&token::Comma) {
103+
match p.expect(exp!(Comma)) {
103104
Err(err) => {
104105
match token::TokenKind::Comma.similar_tokens() {
105106
Some(tks) if tks.contains(&p.token.kind) => {
@@ -123,7 +124,7 @@ fn parse_args<'a>(ecx: &ExtCtxt<'a>, sp: Span, tts: TokenStream) -> PResult<'a,
123124
match p.token.ident() {
124125
Some((ident, _)) if p.look_ahead(1, |t| *t == token::Eq) => {
125126
p.bump();
126-
p.expect(&token::Eq)?;
127+
p.expect(exp!(Eq))?;
127128
let expr = p.parse_expr()?;
128129
if let Some((_, prev)) = args.by_name(ident.name) {
129130
ecx.dcx().emit_err(errors::FormatDuplicateArg {

‎compiler/rustc_builtin_macros/src/pattern_type.rs‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,8 @@ use rustc_ast::tokenstream::TokenStream;
33
use rustc_ast::{Pat, Ty, ast};
44
use rustc_errors::PResult;
55
use rustc_expand::base::{self, DummyResult, ExpandResult, ExtCtxt, MacroExpanderResult};
6-
use rustc_span::{Span, sym};
6+
use rustc_parse::exp;
7+
use rustc_span::Span;
78

89
pub(crate) fn expand<'cx>(
910
cx: &'cx mut ExtCtxt<'_>,
@@ -24,7 +25,7 @@ fn parse_pat_ty<'a>(cx: &mut ExtCtxt<'a>, stream: TokenStream) -> PResult<'a, (P
2425
let mut parser = cx.new_parser_from_tts(stream);
2526

2627
let ty = parser.parse_ty()?;
27-
parser.expect_keyword(sym::is)?;
28+
parser.expect_keyword(exp!(Is))?;
2829
let pat = parser.parse_pat_no_top_alt(None, None)?;
2930

3031
Ok((ty, pat))

‎compiler/rustc_builtin_macros/src/util.rs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@ use rustc_expand::expand::AstFragment;
77
use rustc_feature::AttributeTemplate;
88
use rustc_lint_defs::BuiltinLintDiag;
99
use rustc_lint_defs::builtin::DUPLICATE_MACRO_ATTRIBUTES;
10-
use rustc_parse::{parser, validate_attr};
10+
use rustc_parse::{exp, parser, validate_attr};
1111
use rustc_session::errors::report_lit_error;
1212
use rustc_span::{BytePos, Span, Symbol};
1313

@@ -204,7 +204,7 @@ pub(crate) fn get_single_expr_from_tts(
204204
Ok(ret) => ret,
205205
Err(guar) => return ExpandResult::Ready(Err(guar)),
206206
};
207-
let _ = p.eat(&token::Comma);
207+
let _ = p.eat(exp!(Comma));
208208

209209
if p.token != token::Eof {
210210
cx.dcx().emit_err(errors::OnlyOneArgument { span, name });
@@ -237,7 +237,7 @@ pub(crate) fn get_exprs_from_tts(
237237
let expr = cx.expander().fully_expand_fragment(AstFragment::Expr(expr)).make_expr();
238238

239239
es.push(expr);
240-
if p.eat(&token::Comma) {
240+
if p.eat(exp!(Comma)) {
241241
continue;
242242
}
243243
if p.token != token::Eof {

0 commit comments

Comments
 (0)