// fn foo() { crate::foo(); }
T![crate] if !p.nth_at(1, T![::]) => {
let m = p.start();
- p.bump_any();
+ p.bump(T![crate]);
m.complete(p, VISIBILITY);
}
_ => return false,
fn opt_alias(p: &mut Parser) {
if p.at(T![as]) {
let m = p.start();
- p.bump_any();
+ p.bump(T![as]);
if !p.eat(T![_]) {
name(p);
}
fn abi(p: &mut Parser) {
assert!(p.at(T![extern]));
let abi = p.start();
- p.bump_any();
+ p.bump(T![extern]);
match p.current() {
STRING | RAW_STRING => p.bump_any(),
_ => (),
fn name_r(p: &mut Parser, recovery: TokenSet) {
if p.at(IDENT) {
let m = p.start();
- p.bump_any();
+ p.bump(IDENT);
m.complete(p, NAME);
} else {
p.err_recover("expected a name", recovery);
fn name_ref(p: &mut Parser) {
if p.at(IDENT) {
let m = p.start();
- p.bump_any();
+ p.bump(IDENT);
m.complete(p, NAME_REF);
} else if p.at(T![self]) {
let m = p.start();
- p.bump_any();
+ p.bump(T![self]);
m.complete(p, T![self]);
} else {
p.err_and_bump("expected identifier");
assert!(p.at(T!['{']));
let m = p.start();
p.error(message);
- p.bump_any();
+ p.bump(T!['{']);
expressions::expr_block_contents(p);
p.eat(T!['}']);
m.complete(p, ERROR);
fn attribute(p: &mut Parser, inner: bool) {
let attr = p.start();
assert!(p.at(T![#]));
- p.bump_any();
+ p.bump(T![#]);
if inner {
assert!(p.at(T![!]));
- p.bump_any();
+ p.bump(T![!]);
}
if p.at(T!['[']) {
pub(crate) fn naked_block(p: &mut Parser) {
assert!(p.at(T!['{']));
let m = p.start();
- p.bump_any();
+ p.bump(T!['{']);
expr_block_contents(p);
p.expect(T!['}']);
m.complete(p, BLOCK);
// }
fn let_stmt(p: &mut Parser, m: Marker, with_semi: StmtWithSemi) {
assert!(p.at(T![let]));
- p.bump_any();
+ p.bump(T![let]);
patterns::pattern(p);
if p.at(T![:]) {
types::ascription(p);
// }
if p.at(T![;]) {
- p.bump_any();
+ p.bump(T![;]);
continue;
}
// }
T![&] => {
m = p.start();
- p.bump_any();
+ p.bump(T![&]);
p.eat(T![mut]);
REF_EXPR
}
fn index_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
assert!(p.at(T!['[']));
let m = lhs.precede(p);
- p.bump_any();
+ p.bump(T!['[']);
expr(p);
p.expect(T![']']);
m.complete(p, INDEX_EXPR)
fn field_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
assert!(p.at(T![.]));
let m = lhs.precede(p);
- p.bump_any();
+ p.bump(T![.]);
if p.at(IDENT) || p.at(INT_NUMBER) {
name_ref_or_index(p)
} else if p.at(FLOAT_NUMBER) {
fn try_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
assert!(p.at(T![?]));
let m = lhs.precede(p);
- p.bump_any();
+ p.bump(T![?]);
m.complete(p, TRY_EXPR)
}
fn cast_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
assert!(p.at(T![as]));
let m = lhs.precede(p);
- p.bump_any();
+ p.bump(T![as]);
// Use type_no_bounds(), because cast expressions are not
// allowed to have bounds.
types::type_no_bounds(p);
fn arg_list(p: &mut Parser) {
assert!(p.at(T!['(']));
let m = p.start();
- p.bump_any();
+ p.bump(T!['(']);
while !p.at(T![')']) && !p.at(EOF) {
if !p.at_ts(EXPR_FIRST) {
p.error("expected expression");
pub(crate) fn record_field_list(p: &mut Parser) {
assert!(p.at(T!['{']));
let m = p.start();
- p.bump_any();
+ p.bump(T!['{']);
while !p.at(EOF) && !p.at(T!['}']) {
match p.current() {
// test record_literal_field_with_attr
}
T![async] if la == T!['{'] || (la == T![move] && p.nth(2) == T!['{']) => {
let m = p.start();
- p.bump_any();
+ p.bump(T![async]);
p.eat(T![move]);
block_expr(p, Some(m))
}
T![match] => match_expr(p),
T![unsafe] if la == T!['{'] => {
let m = p.start();
- p.bump_any();
+ p.bump(T![unsafe]);
block_expr(p, Some(m))
}
T!['{'] => {
fn array_expr(p: &mut Parser) -> CompletedMarker {
assert!(p.at(T!['[']));
let m = p.start();
- p.bump_any();
+ p.bump(T!['[']);
if p.eat(T![']']) {
return m.complete(p, ARRAY_EXPR);
}
fn if_expr(p: &mut Parser) -> CompletedMarker {
assert!(p.at(T![if]));
let m = p.start();
- p.bump_any();
+ p.bump(T![if]);
cond(p);
block(p);
if p.at(T![else]) {
- p.bump_any();
+ p.bump(T![else]);
if p.at(T![if]) {
if_expr(p);
} else {
fn label(p: &mut Parser) {
assert!(p.at(LIFETIME) && p.nth(1) == T![:]);
let m = p.start();
- p.bump_any();
+ p.bump(LIFETIME);
p.bump_any();
m.complete(p, LABEL);
}
fn loop_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
assert!(p.at(T![loop]));
let m = m.unwrap_or_else(|| p.start());
- p.bump_any();
+ p.bump(T![loop]);
block(p);
m.complete(p, LOOP_EXPR)
}
fn while_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
assert!(p.at(T![while]));
let m = m.unwrap_or_else(|| p.start());
- p.bump_any();
+ p.bump(T![while]);
cond(p);
block(p);
m.complete(p, WHILE_EXPR)
fn for_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
assert!(p.at(T![for]));
let m = m.unwrap_or_else(|| p.start());
- p.bump_any();
+ p.bump(T![for]);
patterns::pattern(p);
p.expect(T![in]);
expr_no_struct(p);
fn match_expr(p: &mut Parser) -> CompletedMarker {
assert!(p.at(T![match]));
let m = p.start();
- p.bump_any();
+ p.bump(T![match]);
expr_no_struct(p);
if p.at(T!['{']) {
match_arm_list(p);
fn match_guard(p: &mut Parser) -> CompletedMarker {
assert!(p.at(T![if]));
let m = p.start();
- p.bump_any();
+ p.bump(T![if]);
expr(p);
m.complete(p, MATCH_GUARD)
}
fn return_expr(p: &mut Parser) -> CompletedMarker {
assert!(p.at(T![return]));
let m = p.start();
- p.bump_any();
+ p.bump(T![return]);
if p.at_ts(EXPR_FIRST) {
expr(p);
}
fn continue_expr(p: &mut Parser) -> CompletedMarker {
assert!(p.at(T![continue]));
let m = p.start();
- p.bump_any();
+ p.bump(T![continue]);
p.eat(LIFETIME);
m.complete(p, CONTINUE_EXPR)
}
fn break_expr(p: &mut Parser, r: Restrictions) -> CompletedMarker {
assert!(p.at(T![break]));
let m = p.start();
- p.bump_any();
+ p.bump(T![break]);
p.eat(LIFETIME);
// test break_ambiguity
// fn foo(){
fn try_block_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
assert!(p.at(T![try]));
let m = m.unwrap_or_else(|| p.start());
- p.bump_any();
+ p.bump(T![try]);
block(p);
m.complete(p, TRY_EXPR)
}
fn box_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
assert!(p.at(T![box]));
let m = m.unwrap_or_else(|| p.start());
- p.bump_any();
+ p.bump(T![box]);
if p.at_ts(EXPR_FIRST) {
expr(p);
}
} else if p.at(T!['}']) && !stop_on_r_curly {
let e = p.start();
p.error("unmatched `}`");
- p.bump_any();
+ p.bump(T!['}']);
e.complete(p, ERROR);
} else if !p.at(EOF) && !p.at(T!['}']) {
p.err_and_bump("expected an item");
fn extern_crate_item(p: &mut Parser, m: Marker) {
assert!(p.at(T![extern]));
- p.bump_any();
+ p.bump(T![extern]);
assert!(p.at(T![crate]));
- p.bump_any();
+ p.bump(T![crate]);
name_ref(p);
opt_alias(p);
p.expect(T![;]);
pub(crate) fn extern_item_list(p: &mut Parser) {
assert!(p.at(T!['{']));
let m = p.start();
- p.bump_any();
+ p.bump(T!['{']);
mod_contents(p, true);
p.expect(T!['}']);
m.complete(p, EXTERN_ITEM_LIST);
fn fn_def(p: &mut Parser, flavor: ItemFlavor) {
assert!(p.at(T![fn]));
- p.bump_any();
+ p.bump(T![fn]);
name_r(p, ITEM_RECOVERY_SET);
// test function_type_params
// test fn_decl
// trait T { fn foo(); }
if p.at(T![;]) {
- p.bump_any();
+ p.bump(T![;]);
} else {
expressions::block(p)
}
// type Foo = Bar;
fn type_def(p: &mut Parser, m: Marker) {
assert!(p.at(T![type]));
- p.bump_any();
+ p.bump(T![type]);
name(p);
pub(crate) fn mod_item(p: &mut Parser, m: Marker) {
assert!(p.at(T![mod]));
- p.bump_any();
+ p.bump(T![mod]);
name(p);
if p.at(T!['{']) {
pub(crate) fn mod_item_list(p: &mut Parser) {
assert!(p.at(T!['{']));
let m = p.start();
- p.bump_any();
+ p.bump(T!['{']);
mod_contents(p, true);
p.expect(T!['}']);
m.complete(p, ITEM_LIST);
fn const_or_static(p: &mut Parser, m: Marker, kw: SyntaxKind, def: SyntaxKind) {
assert!(p.at(kw));
- p.bump_any();
+ p.bump(kw);
p.eat(T![mut]); // FIXME: validator to forbid const mut
// Allow `_` in place of an identifier in a `const`.
type_params::opt_where_clause(p);
match p.current() {
T![;] => {
- p.bump_any();
+ p.bump(T![;]);
}
T!['{'] => record_field_def_list(p),
_ => {
}
}
T![;] if kind == T![struct] => {
- p.bump_any();
+ p.bump(T![;]);
}
T!['{'] => record_field_def_list(p),
T!['('] if kind == T![struct] => {
pub(super) fn enum_def(p: &mut Parser, m: Marker) {
assert!(p.at(T![enum]));
- p.bump_any();
+ p.bump(T![enum]);
name_r(p, ITEM_RECOVERY_SET);
type_params::opt_type_param_list(p);
type_params::opt_where_clause(p);
pub(crate) fn enum_variant_list(p: &mut Parser) {
assert!(p.at(T!['{']));
let m = p.start();
- p.bump_any();
+ p.bump(T!['{']);
while !p.at(EOF) && !p.at(T!['}']) {
if p.at(T!['{']) {
error_block(p, "expected enum variant");
T!['{'] => record_field_def_list(p),
T!['('] => tuple_field_def_list(p),
T![=] => {
- p.bump_any();
+ p.bump(T![=]);
expressions::expr(p);
}
_ => (),
pub(crate) fn record_field_def_list(p: &mut Parser) {
assert!(p.at(T!['{']));
let m = p.start();
- p.bump_any();
+ p.bump(T!['{']);
while !p.at(T!['}']) && !p.at(EOF) {
if p.at(T!['{']) {
error_block(p, "expected field");
// trait X<U: Debug + Display>: Hash + Clone where U: Copy {}
pub(super) fn trait_def(p: &mut Parser) {
assert!(p.at(T![trait]));
- p.bump_any();
+ p.bump(T![trait]);
name_r(p, ITEM_RECOVERY_SET);
type_params::opt_type_param_list(p);
if p.at(T![:]) {
pub(crate) fn trait_item_list(p: &mut Parser) {
assert!(p.at(T!['{']));
let m = p.start();
- p.bump_any();
+ p.bump(T!['{']);
while !p.at(EOF) && !p.at(T!['}']) {
if p.at(T!['{']) {
error_block(p, "expected an item");
// impl Foo {}
pub(super) fn impl_block(p: &mut Parser) {
assert!(p.at(T![impl]));
- p.bump_any();
+ p.bump(T![impl]);
if choose_type_params_over_qpath(p) {
type_params::opt_type_param_list(p);
}
pub(crate) fn impl_item_list(p: &mut Parser) {
assert!(p.at(T!['{']));
let m = p.start();
- p.bump_any();
+ p.bump(T!['{']);
// test impl_inner_attributes
// enum F{}
// impl F {
pub(super) fn use_item(p: &mut Parser, m: Marker) {
assert!(p.at(T![use]));
- p.bump_any();
+ p.bump(T![use]);
use_tree(p);
p.expect(T![;]);
m.complete(p, USE_ITEM);
p.bump(T![::]);
match p.current() {
T![*] => {
- p.bump_any();
+ p.bump(T![*]);
}
// test use_tree_list_after_path
// use crate::{Item};
pub(crate) fn use_tree_list(p: &mut Parser) {
assert!(p.at(T!['{']));
let m = p.start();
- p.bump_any();
+ p.bump(T!['{']);
while !p.at(EOF) && !p.at(T!['}']) {
use_tree(p);
if !p.at(T!['}']) {
let (bra, ket) = if flavor.type_required() { (T!['('], T![')']) } else { (T![|], T![|]) };
assert!(p.at(bra));
let m = p.start();
- p.bump_any();
+ p.bump(bra);
if flavor.type_required() {
// test self_param_outer_attr
// fn f(#[must_use] self) {}
assert!(is_literal_pat_start(p));
let m = p.start();
if p.at(T![-]) {
- p.bump_any();
+ p.bump(T![-]);
}
expressions::literal(p);
m.complete(p, LITERAL_PAT)
// }
fn tuple_pat_fields(p: &mut Parser) {
assert!(p.at(T!['(']));
- p.bump_any();
+ p.bump(T!['(']);
pat_list(p, T![')']);
p.expect(T![')']);
}
fn record_field_pat_list(p: &mut Parser) {
assert!(p.at(T!['{']));
let m = p.start();
- p.bump_any();
+ p.bump(T!['{']);
while !p.at(EOF) && !p.at(T!['}']) {
match p.current() {
// A trailing `..` is *not* treated as a DOT_DOT_PAT.
fn placeholder_pat(p: &mut Parser) -> CompletedMarker {
assert!(p.at(T![_]));
let m = p.start();
- p.bump_any();
+ p.bump(T![_]);
m.complete(p, PLACEHOLDER_PAT)
}
fn ref_pat(p: &mut Parser) -> CompletedMarker {
assert!(p.at(T![&]));
let m = p.start();
- p.bump_any();
+ p.bump(T![&]);
p.eat(T![mut]);
pattern(p);
m.complete(p, REF_PAT)
fn slice_pat(p: &mut Parser) -> CompletedMarker {
assert!(p.at(T!['[']));
let m = p.start();
- p.bump_any();
+ p.bump(T!['[']);
pat_list(p, T![']']);
p.expect(T![']']);
m.complete(p, SLICE_PAT)
fn box_pat(p: &mut Parser) -> CompletedMarker {
assert!(p.at(T![box]));
let m = p.start();
- p.bump_any();
+ p.bump(T![box]);
pattern(p);
m.complete(p, BOX_PAT)
}
let m = p.start();
match p.current() {
LIFETIME => {
- p.bump_any();
+ p.bump(LIFETIME);
m.complete(p, LIFETIME_ARG);
}
// test associated_type_bounds
fn type_param_list(p: &mut Parser) {
assert!(p.at(T![<]));
let m = p.start();
- p.bump_any();
+ p.bump(T![<]);
while !p.at(EOF) && !p.at(T![>]) {
let m = p.start();
fn lifetime_param(p: &mut Parser, m: Marker) {
assert!(p.at(LIFETIME));
- p.bump_any();
+ p.bump(LIFETIME);
if p.at(T![:]) {
lifetime_bounds(p);
}
// test type_param_default
// struct S<T = i32>;
if p.at(T![=]) {
- p.bump_any();
+ p.bump(T![=]);
types::type_(p)
}
m.complete(p, TYPE_PARAM);
// struct S<T: 'a + ?Sized + (Copy)>;
pub(super) fn bounds(p: &mut Parser) {
assert!(p.at(T![:]));
- p.bump_any();
+ p.bump(T![:]);
bounds_without_colon(p);
}
fn lifetime_bounds(p: &mut Parser) {
assert!(p.at(T![:]));
- p.bump_any();
+ p.bump(T![:]);
while p.at(LIFETIME) {
- p.bump_any();
+ p.bump(LIFETIME);
if !p.eat(T![+]) {
break;
}
let has_paren = p.eat(T!['(']);
p.eat(T![?]);
match p.current() {
- LIFETIME => p.bump_any(),
+ LIFETIME => p.bump(LIFETIME),
T![for] => types::for_type(p),
_ if paths::is_use_path_start(p) => types::path_type_(p, false),
_ => {
return;
}
let m = p.start();
- p.bump_any();
+ p.bump(T![where]);
while is_where_predicate(p) {
where_predicate(p);
let m = p.start();
match p.current() {
LIFETIME => {
- p.bump_any();
+ p.bump(LIFETIME);
if p.at(T![:]) {
bounds(p);
} else {
fn paren_or_tuple_type(p: &mut Parser) {
assert!(p.at(T!['(']));
let m = p.start();
- p.bump_any();
+ p.bump(T!['(']);
let mut n_types: u32 = 0;
let mut trailing_comma: bool = false;
while !p.at(EOF) && !p.at(T![')']) {
fn never_type(p: &mut Parser) {
assert!(p.at(T![!]));
let m = p.start();
- p.bump_any();
+ p.bump(T![!]);
m.complete(p, NEVER_TYPE);
}
fn pointer_type(p: &mut Parser) {
assert!(p.at(T![*]));
let m = p.start();
- p.bump_any();
+ p.bump(T![*]);
match p.current() {
// test pointer_type_mut
fn array_or_slice_type(p: &mut Parser) {
assert!(p.at(T!['[']));
let m = p.start();
- p.bump_any();
+ p.bump(T!['[']);
type_(p);
let kind = match p.current() {
// test slice_type
// type T = [()];
T![']'] => {
- p.bump_any();
+ p.bump(T![']']);
SLICE_TYPE
}
// test array_type
// type T = [(); 92];
T![;] => {
- p.bump_any();
+ p.bump(T![;]);
expressions::expr(p);
p.expect(T![']']);
ARRAY_TYPE
fn reference_type(p: &mut Parser) {
assert!(p.at(T![&]));
let m = p.start();
- p.bump_any();
+ p.bump(T![&]);
p.eat(LIFETIME);
p.eat(T![mut]);
type_no_bounds(p);
fn placeholder_type(p: &mut Parser) {
assert!(p.at(T![_]));
let m = p.start();
- p.bump_any();
+ p.bump(T![_]);
m.complete(p, PLACEHOLDER_TYPE);
}
pub(super) fn for_binder(p: &mut Parser) {
assert!(p.at(T![for]));
- p.bump_any();
+ p.bump(T![for]);
if p.at(T![<]) {
type_params::opt_type_param_list(p);
} else {
fn impl_trait_type(p: &mut Parser) {
assert!(p.at(T![impl]));
let m = p.start();
- p.bump_any();
+ p.bump(T![impl]);
type_params::bounds_without_colon(p);
m.complete(p, IMPL_TRAIT_TYPE);
}
fn dyn_trait_type(p: &mut Parser) {
assert!(p.at(T![dyn ]));
let m = p.start();
- p.bump_any();
+ p.bump(T![dyn ]);
type_params::bounds_without_colon(p);
m.complete(p, DYN_TRAIT_TYPE);
}