language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-09-27 04:19:13 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Run cargo fix --edition-idioms

Browse source
This commit is contained in:
Amos Wenger 2022-07-20 15:02:08 +02:00
parent 23d25a3094
commit 816f7fe12a
230 changed files with 888 additions and 888 deletions
Download patch file Download diff file Expand all files Collapse all files

54
crates/parser/src/grammar.rs
View file

@ -50,36 +50,36 @@ pub(crate) mod entry {
pub(crate) mod prefix {
use super::*;
pub(crate) fn vis(p: &mut Parser) {
pub(crate) fn vis(p: &mut Parser<'_>) {
let _ = opt_visibility(p, false);
}
pub(crate) fn block(p: &mut Parser) {
pub(crate) fn block(p: &mut Parser<'_>) {
expressions::block_expr(p);
}
pub(crate) fn stmt(p: &mut Parser) {
pub(crate) fn stmt(p: &mut Parser<'_>) {
expressions::stmt(p, expressions::Semicolon::Forbidden);
}
pub(crate) fn pat(p: &mut Parser) {
pub(crate) fn pat(p: &mut Parser<'_>) {
patterns::pattern_single(p);
}
pub(crate) fn ty(p: &mut Parser) {
pub(crate) fn ty(p: &mut Parser<'_>) {
types::type_(p);
}
pub(crate) fn expr(p: &mut Parser) {
pub(crate) fn expr(p: &mut Parser<'_>) {
let _ = expressions::expr(p);
}
pub(crate) fn path(p: &mut Parser) {
pub(crate) fn path(p: &mut Parser<'_>) {
let _ = paths::type_path(p);
}
pub(crate) fn item(p: &mut Parser) {
pub(crate) fn item(p: &mut Parser<'_>) {
items::item_or_macro(p, true);
}
// Parse a meta item , which excluded [], e.g : #[ MetaItem ]
pub(crate) fn meta_item(p: &mut Parser) {
pub(crate) fn meta_item(p: &mut Parser<'_>) {
attributes::meta(p);
}
}
@ -87,14 +87,14 @@ pub(crate) mod entry {
pub(crate) mod top {
use super::*;
pub(crate) fn source_file(p: &mut Parser) {
pub(crate) fn source_file(p: &mut Parser<'_>) {
let m = p.start();
p.eat(SHEBANG);
items::mod_contents(p, false);
m.complete(p, SOURCE_FILE);
}
pub(crate) fn macro_stmts(p: &mut Parser) {
pub(crate) fn macro_stmts(p: &mut Parser<'_>) {
let m = p.start();
while !p.at(EOF) {
@ -104,13 +104,13 @@ pub(crate) mod entry {
m.complete(p, MACRO_STMTS);
}
pub(crate) fn macro_items(p: &mut Parser) {
pub(crate) fn macro_items(p: &mut Parser<'_>) {
let m = p.start();
items::mod_contents(p, false);
m.complete(p, MACRO_ITEMS);
}
pub(crate) fn pattern(p: &mut Parser) {
pub(crate) fn pattern(p: &mut Parser<'_>) {
let m = p.start();
patterns::pattern_top(p);
if p.at(EOF) {
@ -123,7 +123,7 @@ pub(crate) mod entry {
m.complete(p, ERROR);
}
pub(crate) fn type_(p: &mut Parser) {
pub(crate) fn type_(p: &mut Parser<'_>) {
let m = p.start();
types::type_(p);
if p.at(EOF) {
@ -136,7 +136,7 @@ pub(crate) mod entry {
m.complete(p, ERROR);
}
pub(crate) fn expr(p: &mut Parser) {
pub(crate) fn expr(p: &mut Parser<'_>) {
let m = p.start();
expressions::expr(p);
if p.at(EOF) {
@ -149,7 +149,7 @@ pub(crate) mod entry {
m.complete(p, ERROR);
}
pub(crate) fn meta_item(p: &mut Parser) {
pub(crate) fn meta_item(p: &mut Parser<'_>) {
let m = p.start();
attributes::meta(p);
if p.at(EOF) {
@ -168,7 +168,7 @@ pub(crate) fn reparser(
node: SyntaxKind,
first_child: Option<SyntaxKind>,
parent: Option<SyntaxKind>,
) -> Option<fn(&mut Parser)> {
) -> Option<fn(&mut Parser<'_>)> {
let res = match node {
BLOCK_EXPR => expressions::block_expr,
RECORD_FIELD_LIST => items::record_field_list,
@ -200,7 +200,7 @@ impl BlockLike {
}
}
fn opt_visibility(p: &mut Parser, in_tuple_field: bool) -> bool {
fn opt_visibility(p: &mut Parser<'_>, in_tuple_field: bool) -> bool {
match p.current() {
T![pub] => {
let m = p.start();
@ -262,7 +262,7 @@ fn opt_visibility(p: &mut Parser, in_tuple_field: bool) -> bool {
}
}
fn opt_rename(p: &mut Parser) {
fn opt_rename(p: &mut Parser<'_>) {
if p.at(T![as]) {
let m = p.start();
p.bump(T![as]);
@ -273,7 +273,7 @@ fn opt_rename(p: &mut Parser) {
}
}
fn abi(p: &mut Parser) {
fn abi(p: &mut Parser<'_>) {
assert!(p.at(T![extern]));
let abi = p.start();
p.bump(T![extern]);
@ -281,7 +281,7 @@ fn abi(p: &mut Parser) {
abi.complete(p, ABI);
}
fn opt_ret_type(p: &mut Parser) -> bool {
fn opt_ret_type(p: &mut Parser<'_>) -> bool {
if p.at(T![->]) {
let m = p.start();
p.bump(T![->]);
@ -293,7 +293,7 @@ fn opt_ret_type(p: &mut Parser) -> bool {
}
}
fn name_r(p: &mut Parser, recovery: TokenSet) {
fn name_r(p: &mut Parser<'_>, recovery: TokenSet) {
if p.at(IDENT) {
let m = p.start();
p.bump(IDENT);
@ -303,11 +303,11 @@ fn name_r(p: &mut Parser, recovery: TokenSet) {
}
}
fn name(p: &mut Parser) {
fn name(p: &mut Parser<'_>) {
name_r(p, TokenSet::EMPTY);
}
fn name_ref(p: &mut Parser) {
fn name_ref(p: &mut Parser<'_>) {
if p.at(IDENT) {
let m = p.start();
p.bump(IDENT);
@ -317,21 +317,21 @@ fn name_ref(p: &mut Parser) {
}
}
fn name_ref_or_index(p: &mut Parser) {
fn name_ref_or_index(p: &mut Parser<'_>) {
assert!(p.at(IDENT) || p.at(INT_NUMBER));
let m = p.start();
p.bump_any();
m.complete(p, NAME_REF);
}
fn lifetime(p: &mut Parser) {
fn lifetime(p: &mut Parser<'_>) {
assert!(p.at(LIFETIME_IDENT));
let m = p.start();
p.bump(LIFETIME_IDENT);
m.complete(p, LIFETIME);
}
fn error_block(p: &mut Parser, message: &str) {
fn error_block(p: &mut Parser<'_>, message: &str) {
assert!(p.at(T!['{']));
let m = p.start();
p.error(message);

8
crates/parser/src/grammar/attributes.rs
View file

@ -1,18 +1,18 @@
use super::*;
pub(super) fn inner_attrs(p: &mut Parser) {
pub(super) fn inner_attrs(p: &mut Parser<'_>) {
while p.at(T![#]) && p.nth(1) == T![!] {
attr(p, true);
}
}
pub(super) fn outer_attrs(p: &mut Parser) {
pub(super) fn outer_attrs(p: &mut Parser<'_>) {
while p.at(T![#]) {
attr(p, false);
}
}
fn attr(p: &mut Parser, inner: bool) {
fn attr(p: &mut Parser<'_>, inner: bool) {
assert!(p.at(T![#]));
let attr = p.start();
@ -34,7 +34,7 @@ fn attr(p: &mut Parser, inner: bool) {
attr.complete(p, ATTR);
}
pub(super) fn meta(p: &mut Parser) {
pub(super) fn meta(p: &mut Parser<'_>) {
let meta = p.start();
paths::use_path(p);

42
crates/parser/src/grammar/expressions.rs
View file

@ -14,17 +14,17 @@ pub(super) enum Semicolon {
const EXPR_FIRST: TokenSet = LHS_FIRST;
pub(super) fn expr(p: &mut Parser) -> bool {
pub(super) fn expr(p: &mut Parser<'_>) -> bool {
let r = Restrictions { forbid_structs: false, prefer_stmt: false };
expr_bp(p, None, r, 1).is_some()
}
pub(super) fn expr_stmt(p: &mut Parser, m: Option<Marker>) -> Option<(CompletedMarker, BlockLike)> {
pub(super) fn expr_stmt(p: &mut Parser<'_>, m: Option<Marker>) -> Option<(CompletedMarker, BlockLike)> {
let r = Restrictions { forbid_structs: false, prefer_stmt: true };
expr_bp(p, m, r, 1)
}
fn expr_no_struct(p: &mut Parser) {
fn expr_no_struct(p: &mut Parser<'_>) {
let r = Restrictions { forbid_structs: true, prefer_stmt: false };
expr_bp(p, None, r, 1);
}
@ -33,12 +33,12 @@ fn expr_no_struct(p: &mut Parser) {
/// It needs to be parsed with lower precedence than `&&`, so that
/// `if let true = true && false` is parsed as `if (let true = true) && (true)`
/// and not `if let true = (true && true)`.
fn expr_let(p: &mut Parser) {
fn expr_let(p: &mut Parser<'_>) {
let r = Restrictions { forbid_structs: true, prefer_stmt: false };
expr_bp(p, None, r, 5);
}
pub(super) fn stmt(p: &mut Parser, semicolon: Semicolon) {
pub(super) fn stmt(p: &mut Parser<'_>, semicolon: Semicolon) {
if p.eat(T![;]) {
return;
}
@ -101,7 +101,7 @@ pub(super) fn stmt(p: &mut Parser, semicolon: Semicolon) {
// test let_stmt
// fn f() { let x: i32 = 92; }
fn let_stmt(p: &mut Parser, m: Marker, with_semi: Semicolon) {
fn let_stmt(p: &mut Parser<'_>, m: Marker, with_semi: Semicolon) {
p.bump(T![let]);
patterns::pattern(p);
if p.at(T![:]) {
@ -138,7 +138,7 @@ pub(super) fn stmt(p: &mut Parser, semicolon: Semicolon) {
}
}
pub(super) fn expr_block_contents(p: &mut Parser) {
pub(super) fn expr_block_contents(p: &mut Parser<'_>) {
attributes::inner_attrs(p);
while !p.at(EOF) && !p.at(T!['}']) {
@ -170,7 +170,7 @@ struct Restrictions {
///
/// See <https://matklad.github.io/2020/04/13/simple-but-powerful-pratt-parsing.html>
#[rustfmt::skip]
fn current_op(p: &Parser) -> (u8, SyntaxKind) {
fn current_op(p: &Parser<'_>) -> (u8, SyntaxKind) {
const NOT_AN_OP: (u8, SyntaxKind) = (0, T![@]);
match p.current() {
T![|] if p.at(T![||]) => (3, T![||]),
@ -214,7 +214,7 @@ fn current_op(p: &Parser) -> (u8, SyntaxKind) {
// Parses expression with binding power of at least bp.
fn expr_bp(
p: &mut Parser,
p: &mut Parser<'_>,
m: Option<Marker>,
mut r: Restrictions,
bp: u8,
@ -287,7 +287,7 @@ fn expr_bp(
const LHS_FIRST: TokenSet =
atom::ATOM_EXPR_FIRST.union(TokenSet::new(&[T![&], T![*], T![!], T![.], T![-]]));
fn lhs(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)> {
fn lhs(p: &mut Parser<'_>, r: Restrictions) -> Option<(CompletedMarker, BlockLike)> {
let m;
let kind = match p.current() {
// test ref_expr
@ -356,7 +356,7 @@ fn lhs(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)>
}
fn postfix_expr(
p: &mut Parser,
p: &mut Parser<'_>,
mut lhs: CompletedMarker,
// Calls are disallowed if the type is a block and we prefer statements because the call cannot be disambiguated from a tuple
// E.g. `while true {break}();` is parsed as
@ -392,7 +392,7 @@ fn postfix_expr(
return (lhs, block_like);
fn postfix_dot_expr(
p: &mut Parser,
p: &mut Parser<'_>,
lhs: CompletedMarker,
) -> Result<CompletedMarker, CompletedMarker> {
assert!(p.at(T![.]));
@ -428,7 +428,7 @@ fn postfix_expr(
// let _ = f(<Foo>::func());
// f(<Foo as Trait>::func());
// }
fn call_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
fn call_expr(p: &mut Parser<'_>, lhs: CompletedMarker) -> CompletedMarker {
assert!(p.at(T!['(']));
let m = lhs.precede(p);
arg_list(p);
@ -439,7 +439,7 @@ fn call_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
// fn foo() {
// x[1][2];
// }
fn index_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
fn index_expr(p: &mut Parser<'_>, lhs: CompletedMarker) -> CompletedMarker {
assert!(p.at(T!['[']));
let m = lhs.precede(p);
p.bump(T!['[']);
@ -453,7 +453,7 @@ fn index_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
// x.foo();
// y.bar::<T>(1, 2,);
// }
fn method_call_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
fn method_call_expr(p: &mut Parser<'_>, lhs: CompletedMarker) -> CompletedMarker {
assert!(p.at(T![.]) && p.nth(1) == IDENT && (p.nth(2) == T!['('] || p.nth_at(2, T![::])));
let m = lhs.precede(p);
p.bump_any();
@ -471,7 +471,7 @@ fn method_call_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
// x.0.bar;
// x.0();
// }
fn field_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
fn field_expr(p: &mut Parser<'_>, lhs: CompletedMarker) -> CompletedMarker {
assert!(p.at(T![.]));
let m = lhs.precede(p);
p.bump(T![.]);
@ -490,7 +490,7 @@ fn field_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
// fn foo() {
// x?;
// }
fn try_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
fn try_expr(p: &mut Parser<'_>, lhs: CompletedMarker) -> CompletedMarker {
assert!(p.at(T![?]));
let m = lhs.precede(p);
p.bump(T![?]);
@ -504,7 +504,7 @@ fn try_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
// 79 as i16 - 1;
// 0x36 as u8 <= 0x37;
// }
fn cast_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
fn cast_expr(p: &mut Parser<'_>, lhs: CompletedMarker) -> CompletedMarker {
assert!(p.at(T![as]));
let m = lhs.precede(p);
p.bump(T![as]);
@ -514,7 +514,7 @@ fn cast_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
m.complete(p, CAST_EXPR)
}
fn arg_list(p: &mut Parser) {
fn arg_list(p: &mut Parser<'_>) {
assert!(p.at(T!['(']));
let m = p.start();
p.bump(T!['(']);
@ -541,7 +541,7 @@ fn arg_list(p: &mut Parser) {
// let _ = ::a::<b>;
// let _ = format!();
// }
fn path_expr(p: &mut Parser, r: Restrictions) -> (CompletedMarker, BlockLike) {
fn path_expr(p: &mut Parser<'_>, r: Restrictions) -> (CompletedMarker, BlockLike) {
assert!(paths::is_path_start(p));
let m = p.start();
paths::expr_path(p);
@ -565,7 +565,7 @@ fn path_expr(p: &mut Parser, r: Restrictions) -> (CompletedMarker, BlockLike) {
// S { x, y: 32, ..Default::default() };
// TupleStruct { 0: 1 };
// }
pub(crate) fn record_expr_field_list(p: &mut Parser) {
pub(crate) fn record_expr_field_list(p: &mut Parser<'_>) {
assert!(p.at(T!['{']));
let m = p.start();
p.bump(T!['{']);

46
crates/parser/src/grammar/expressions/atom.rs
View file

@ -24,7 +24,7 @@ pub(crate) const LITERAL_FIRST: TokenSet = TokenSet::new(&[
BYTE_STRING,
]);
pub(crate) fn literal(p: &mut Parser) -> Option<CompletedMarker> {
pub(crate) fn literal(p: &mut Parser<'_>) -> Option<CompletedMarker> {
if !p.at_ts(LITERAL_FIRST) {
return None;
}
@ -60,7 +60,7 @@ pub(super) const ATOM_EXPR_FIRST: TokenSet =
const EXPR_RECOVERY_SET: TokenSet = TokenSet::new(&[T![let]]);
pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMarker, BlockLike)> {
pub(super) fn atom_expr(p: &mut Parser<'_>, r: Restrictions) -> Option<(CompletedMarker, BlockLike)> {
if let Some(m) = literal(p) {
return Some((m, BlockLike::NotBlock));
}
@ -169,7 +169,7 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar
// (1);
// (1,);
// }
fn tuple_expr(p: &mut Parser) -> CompletedMarker {
fn tuple_expr(p: &mut Parser<'_>) -> CompletedMarker {
assert!(p.at(T!['(']));
let m = p.start();
p.expect(T!['(']);
@ -201,7 +201,7 @@ fn tuple_expr(p: &mut Parser) -> CompletedMarker {
// [1, 2,];
// [1; 2];
// }
fn array_expr(p: &mut Parser) -> CompletedMarker {
fn array_expr(p: &mut Parser<'_>) -> CompletedMarker {
assert!(p.at(T!['[']));
let m = p.start();
@ -248,7 +248,7 @@ fn array_expr(p: &mut Parser) -> CompletedMarker {
// for<'a> || {};
// for<'a> move || {};
// }
fn closure_expr(p: &mut Parser) -> CompletedMarker {
fn closure_expr(p: &mut Parser<'_>) -> CompletedMarker {
assert!(match p.current() {
T![static] | T![async] | T![move] | T![|] => true,
T![for] => p.nth(1) == T![<],
@ -290,7 +290,7 @@ fn closure_expr(p: &mut Parser) -> CompletedMarker {
// if S {};
// if { true } { } else { };
// }
fn if_expr(p: &mut Parser) -> CompletedMarker {
fn if_expr(p: &mut Parser<'_>) -> CompletedMarker {
assert!(p.at(T![if]));
let m = p.start();
p.bump(T![if]);
@ -313,7 +313,7 @@ fn if_expr(p: &mut Parser) -> CompletedMarker {
// 'b: while true {}
// 'c: for x in () {}
// }
fn label(p: &mut Parser) {
fn label(p: &mut Parser<'_>) {
assert!(p.at(LIFETIME_IDENT) && p.nth(1) == T![:]);
let m = p.start();
lifetime(p);
@ -325,7 +325,7 @@ fn label(p: &mut Parser) {
// fn foo() {
// loop {};
// }
fn loop_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
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(T![loop]);
@ -339,7 +339,7 @@ fn loop_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
// while let Some(x) = it.next() {};
// while { true } {};
// }
fn while_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
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(T![while]);
@ -352,7 +352,7 @@ fn while_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
// fn foo() {
// for x in [] {};
// }
fn for_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
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(T![for]);
@ -368,7 +368,7 @@ fn for_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
// if let Some(_) = None && true {}
// while 1 == 5 && (let None = None) {}
// }
fn let_expr(p: &mut Parser) -> CompletedMarker {
fn let_expr(p: &mut Parser<'_>) -> CompletedMarker {
let m = p.start();
p.bump(T![let]);
patterns::pattern_top(p);
@ -384,7 +384,7 @@ fn let_expr(p: &mut Parser) -> CompletedMarker {
// match { } { _ => () };
// match { S {} } {};
// }
fn match_expr(p: &mut Parser) -> CompletedMarker {
fn match_expr(p: &mut Parser<'_>) -> CompletedMarker {
assert!(p.at(T![match]));
let m = p.start();
p.bump(T![match]);
@ -397,7 +397,7 @@ fn match_expr(p: &mut Parser) -> CompletedMarker {
m.complete(p, MATCH_EXPR)
}
pub(crate) fn match_arm_list(p: &mut Parser) {
pub(crate) fn match_arm_list(p: &mut Parser<'_>) {
assert!(p.at(T!['{']));
let m = p.start();
p.eat(T!['{']);
@ -434,7 +434,7 @@ pub(crate) fn match_arm_list(p: &mut Parser) {
// | X => (),
// };
// }
fn match_arm(p: &mut Parser) {
fn match_arm(p: &mut Parser<'_>) {
let m = p.start();
// test match_arms_outer_attributes
// fn foo() {
@ -482,7 +482,7 @@ fn match_arm(p: &mut Parser) {
// _ if let foo = bar => (),
// }
// }
fn match_guard(p: &mut Parser) -> CompletedMarker {
fn match_guard(p: &mut Parser<'_>) -> CompletedMarker {
assert!(p.at(T![if]));
let m = p.start();
p.bump(T![if]);
@ -495,7 +495,7 @@ fn match_guard(p: &mut Parser) -> CompletedMarker {
// fn b() { let _ = 1; }
// fn c() { 1; 2; }
// fn d() { 1; 2 }
pub(crate) fn block_expr(p: &mut Parser) {
pub(crate) fn block_expr(p: &mut Parser<'_>) {
if !p.at(T!['{']) {
p.error("expected a block");
return;
@ -505,7 +505,7 @@ pub(crate) fn block_expr(p: &mut Parser) {
m.complete(p, BLOCK_EXPR);
}
fn stmt_list(p: &mut Parser) -> CompletedMarker {
fn stmt_list(p: &mut Parser<'_>) -> CompletedMarker {
assert!(p.at(T!['{']));
let m = p.start();
p.bump(T!['{']);
@ -519,7 +519,7 @@ fn stmt_list(p: &mut Parser) -> CompletedMarker {
// return;
// return 92;
// }
fn return_expr(p: &mut Parser) -> CompletedMarker {
fn return_expr(p: &mut Parser<'_>) -> CompletedMarker {
assert!(p.at(T![return]));
let m = p.start();
p.bump(T![return]);
@ -533,7 +533,7 @@ fn return_expr(p: &mut Parser) -> CompletedMarker {
// yield;
// yield 1;
// }
fn yield_expr(p: &mut Parser) -> CompletedMarker {
fn yield_expr(p: &mut Parser<'_>) -> CompletedMarker {
assert!(p.at(T![yield]));
let m = p.start();
p.bump(T![yield]);
@ -550,7 +550,7 @@ fn yield_expr(p: &mut Parser) -> CompletedMarker {
// continue 'l;
// }
// }
fn continue_expr(p: &mut Parser) -> CompletedMarker {
fn continue_expr(p: &mut Parser<'_>) -> CompletedMarker {
assert!(p.at(T![continue]));
let m = p.start();
p.bump(T![continue]);
@ -569,7 +569,7 @@ fn continue_expr(p: &mut Parser) -> CompletedMarker {
// break 'l 92;
// }
// }
fn break_expr(p: &mut Parser, r: Restrictions) -> CompletedMarker {
fn break_expr(p: &mut Parser<'_>, r: Restrictions) -> CompletedMarker {
assert!(p.at(T![break]));
let m = p.start();
p.bump(T![break]);
@ -593,7 +593,7 @@ fn break_expr(p: &mut Parser, r: Restrictions) -> CompletedMarker {
// fn foo() {
// let _ = try {};
// }
fn try_block_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
fn try_block_expr(p: &mut Parser<'_>, m: Option<Marker>) -> CompletedMarker {
assert!(p.at(T![try]));
let m = m.unwrap_or_else(|| p.start());
// Special-case `try!` as macro.
@ -629,7 +629,7 @@ fn try_block_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
// let y = (box 1i32, box 2i32);
// let z = Foo(box 1i32, box 2i32);
// }
fn box_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
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(T![box]);

12
crates/parser/src/grammar/generic_args.rs
View file

@ -1,6 +1,6 @@
use super::*;
pub(super) fn opt_generic_arg_list(p: &mut Parser, colon_colon_required: bool) {
pub(super) fn opt_generic_arg_list(p: &mut Parser<'_>, colon_colon_required: bool) {
let m;
if p.at(T![::]) && p.nth(2) == T![<] {
m = p.start();
@ -25,7 +25,7 @@ pub(super) fn opt_generic_arg_list(p: &mut Parser, colon_colon_required: bool) {
// test generic_arg
// type T = S<i32>;
fn generic_arg(p: &mut Parser) {
fn generic_arg(p: &mut Parser<'_>) {
match p.current() {
LIFETIME_IDENT => lifetime_arg(p),
T!['{'] | T![true] | T![false] | T![-] => const_arg(p),
@ -74,13 +74,13 @@ fn generic_arg(p: &mut Parser) {
// test lifetime_arg
// type T = S<'static>;
fn lifetime_arg(p: &mut Parser) {
fn lifetime_arg(p: &mut Parser<'_>) {
let m = p.start();
lifetime(p);
m.complete(p, LIFETIME_ARG);
}
pub(super) fn const_arg_expr(p: &mut Parser) {
pub(super) fn const_arg_expr(p: &mut Parser<'_>) {
// The tests in here are really for `const_arg`, which wraps the content
// CONST_ARG.
match p.current() {
@ -118,13 +118,13 @@ pub(super) fn const_arg_expr(p: &mut Parser) {
// test const_arg
// type T = S<92>;
pub(super) fn const_arg(p: &mut Parser) {
pub(super) fn const_arg(p: &mut Parser<'_>) {
let m = p.start();
const_arg_expr(p);
m.complete(p, CONST_ARG);
}
fn type_arg(p: &mut Parser) {
fn type_arg(p: &mut Parser<'_>) {
let m = p.start();
types::type_(p);
m.complete(p, TYPE_ARG);

28
crates/parser/src/grammar/generic_params.rs
View file

@ -1,6 +1,6 @@
use super::*;
pub(super) fn opt_generic_param_list(p: &mut Parser) {
pub(super) fn opt_generic_param_list(p: &mut Parser<'_>) {
if p.at(T![<]) {
generic_param_list(p);
}
@ -8,7 +8,7 @@ pub(super) fn opt_generic_param_list(p: &mut Parser) {
// test generic_param_list
// fn f<T: Clone>() {}
fn generic_param_list(p: &mut Parser) {
fn generic_param_list(p: &mut Parser<'_>) {
assert!(p.at(T![<]));
let m = p.start();
p.bump(T![<]);
@ -23,7 +23,7 @@ fn generic_param_list(p: &mut Parser) {
m.complete(p, GENERIC_PARAM_LIST);
}
fn generic_param(p: &mut Parser) {
fn generic_param(p: &mut Parser<'_>) {
let m = p.start();
// test generic_param_attribute
// fn foo<#[lt_attr] 'a, #[t_attr] T>() {}
@ -41,7 +41,7 @@ fn generic_param(p: &mut Parser) {
// test lifetime_param
// fn f<'a: 'b>() {}
fn lifetime_param(p: &mut Parser, m: Marker) {
fn lifetime_param(p: &mut Parser<'_>, m: Marker) {
assert!(p.at(LIFETIME_IDENT));
lifetime(p);
if p.at(T![:]) {
@ -52,7 +52,7 @@ fn lifetime_param(p: &mut Parser, m: Marker) {
// test type_param
// fn f<T: Clone>() {}
fn type_param(p: &mut Parser, m: Marker) {
fn type_param(p: &mut Parser<'_>, m: Marker) {
assert!(p.at(IDENT));
name(p);
if p.at(T![:]) {
@ -69,7 +69,7 @@ fn type_param(p: &mut Parser, m: Marker) {
// test const_param
// struct S<const N: u32>;
fn const_param(p: &mut Parser, m: Marker) {
fn const_param(p: &mut Parser<'_>, m: Marker) {
p.bump(T![const]);
name(p);
if p.at(T![:]) {
@ -94,7 +94,7 @@ fn const_param(p: &mut Parser, m: Marker) {
m.complete(p, CONST_PARAM);
}
fn lifetime_bounds(p: &mut Parser) {
fn lifetime_bounds(p: &mut Parser<'_>) {
assert!(p.at(T![:]));
p.bump(T![:]);
while p.at(LIFETIME_IDENT) {
@ -107,18 +107,18 @@ fn lifetime_bounds(p: &mut Parser) {
// test type_param_bounds
// struct S<T: 'a + ?Sized + (Copy) + ~const Drop>;
pub(super) fn bounds(p: &mut Parser) {
pub(super) fn bounds(p: &mut Parser<'_>) {
assert!(p.at(T![:]));
p.bump(T![:]);
bounds_without_colon(p);
}
pub(super) fn bounds_without_colon(p: &mut Parser) {
pub(super) fn bounds_without_colon(p: &mut Parser<'_>) {
let m = p.start();
bounds_without_colon_m(p, m);
}
pub(super) fn bounds_without_colon_m(p: &mut Parser, marker: Marker) -> CompletedMarker {
pub(super) fn bounds_without_colon_m(p: &mut Parser<'_>, marker: Marker) -> CompletedMarker {
while type_bound(p) {
if !p.eat(T![+]) {
break;
@ -127,7 +127,7 @@ pub(super) fn bounds_without_colon_m(p: &mut Parser, marker: Marker) -> Complete
marker.complete(p, TYPE_BOUND_LIST)
}
fn type_bound(p: &mut Parser) -> bool {
fn type_bound(p: &mut Parser<'_>) -> bool {
let m = p.start();
let has_paren = p.eat(T!['(']);
match p.current() {
@ -172,7 +172,7 @@ fn type_bound(p: &mut Parser) -> bool {
// Iterator::Item: 'a,
// <T as Iterator>::Item: 'a
// {}
pub(super) fn opt_where_clause(p: &mut Parser) {
pub(super) fn opt_where_clause(p: &mut Parser<'_>) {
if !p.at(T![where]) {
return;
}
@ -196,7 +196,7 @@ pub(super) fn opt_where_clause(p: &mut Parser) {
m.complete(p, WHERE_CLAUSE);
fn is_where_predicate(p: &mut Parser) -> bool {
fn is_where_predicate(p: &mut Parser<'_>) -> bool {
match p.current() {
LIFETIME_IDENT => true,
T![impl] => false,
@ -205,7 +205,7 @@ pub(super) fn opt_where_clause(p: &mut Parser) {
}
}
fn where_predicate(p: &mut Parser) {
fn where_predicate(p: &mut Parser<'_>) {
let m = p.start();
match p.current() {
LIFETIME_IDENT => {

30
crates/parser/src/grammar/items.rs
View file

@ -17,7 +17,7 @@ use super::*;
// foo::bar!();
// super::baz! {}
// struct S;
pub(super) fn mod_contents(p: &mut Parser, stop_on_r_curly: bool) {
pub(super) fn mod_contents(p: &mut Parser<'_>, stop_on_r_curly: bool) {
attributes::inner_attrs(p);
while !p.at(EOF) && !(p.at(T!['}']) && stop_on_r_curly) {
item_or_macro(p, stop_on_r_curly);
@ -41,7 +41,7 @@ pub(super) const ITEM_RECOVERY_SET: TokenSet = TokenSet::new(&[
T![;],
]);
pub(super) fn item_or_macro(p: &mut Parser, stop_on_r_curly: bool) {
pub(super) fn item_or_macro(p: &mut Parser<'_>, stop_on_r_curly: bool) {
let m = p.start();
attributes::outer_attrs(p);
@ -84,7 +84,7 @@ pub(super) fn item_or_macro(p: &mut Parser, stop_on_r_curly: bool) {
}
/// Try to parse an item, completing `m` in case of success.
pub(super) fn opt_item(p: &mut Parser, m: Marker) -> Result<(), Marker> {
pub(super) fn opt_item(p: &mut Parser<'_>, m: Marker) -> Result<(), Marker> {
// test_err pub_expr
// fn foo() { pub 92; }
let has_visibility = opt_visibility(p, false);
@ -214,7 +214,7 @@ pub(super) fn opt_item(p: &mut Parser, m: Marker) -> Result<(), Marker> {
Ok(())
}
fn opt_item_without_modifiers(p: &mut Parser, m: Marker) -> Result<(), Marker> {
fn opt_item_without_modifiers(p: &mut Parser<'_>, m: Marker) -> Result<(), Marker> {
let la = p.nth(1);
match p.current() {
T![extern] if la == T![crate] => extern_crate(p, m),
@ -239,7 +239,7 @@ fn opt_item_without_modifiers(p: &mut Parser, m: Marker) -> Result<(), Marker> {
// test extern_crate
// extern crate foo;
fn extern_crate(p: &mut Parser, m: Marker) {
fn extern_crate(p: &mut Parser<'_>, m: Marker) {
p.bump(T![extern]);
p.bump(T![crate]);
@ -262,7 +262,7 @@ fn extern_crate(p: &mut Parser, m: Marker) {
// test mod_item
// mod a;
pub(crate) fn mod_item(p: &mut Parser, m: Marker) {
pub(crate) fn mod_item(p: &mut Parser<'_>, m: Marker) {
p.bump(T![mod]);
name(p);
if p.at(T!['{']) {
@ -277,7 +277,7 @@ pub(crate) fn mod_item(p: &mut Parser, m: Marker) {
// test type_alias
// type Foo = Bar;
fn type_alias(p: &mut Parser, m: Marker) {
fn type_alias(p: &mut Parser<'_>, m: Marker) {
p.bump(T![type]);
name(p);
@ -305,7 +305,7 @@ fn type_alias(p: &mut Parser, m: Marker) {
m.complete(p, TYPE_ALIAS);
}
pub(crate) fn item_list(p: &mut Parser) {
pub(crate) fn item_list(p: &mut Parser<'_>) {
assert!(p.at(T!['{']));
let m = p.start();
p.bump(T!['{']);
@ -314,7 +314,7 @@ pub(crate) fn item_list(p: &mut Parser) {
m.complete(p, ITEM_LIST);
}
pub(crate) fn extern_item_list(p: &mut Parser) {
pub(crate) fn extern_item_list(p: &mut Parser<'_>) {
assert!(p.at(T!['{']));
let m = p.start();
p.bump(T!['{']);
@ -323,7 +323,7 @@ pub(crate) fn extern_item_list(p: &mut Parser) {
m.complete(p, EXTERN_ITEM_LIST);
}
fn macro_rules(p: &mut Parser, m: Marker) {
fn macro_rules(p: &mut Parser<'_>, m: Marker) {
assert!(p.at_contextual_kw(T![macro_rules]));
p.bump_remap(T![macro_rules]);
p.expect(T![!]);
@ -358,7 +358,7 @@ fn macro_rules(p: &mut Parser, m: Marker) {
// test macro_def
// macro m($i:ident) {}
fn macro_def(p: &mut Parser, m: Marker) {
fn macro_def(p: &mut Parser<'_>, m: Marker) {
p.expect(T![macro]);
name_r(p, ITEM_RECOVERY_SET);
if p.at(T!['{']) {
@ -382,7 +382,7 @@ fn macro_def(p: &mut Parser, m: Marker) {
// test fn
// fn foo() {}
fn fn_(p: &mut Parser, m: Marker) {
fn fn_(p: &mut Parser<'_>, m: Marker) {
p.bump(T![fn]);
name_r(p, ITEM_RECOVERY_SET);
@ -414,13 +414,13 @@ fn fn_(p: &mut Parser, m: Marker) {
m.complete(p, FN);
}
fn macro_call(p: &mut Parser) -> BlockLike {
fn macro_call(p: &mut Parser<'_>) -> BlockLike {
assert!(paths::is_use_path_start(p));
paths::use_path(p);
macro_call_after_excl(p)
}
pub(super) fn macro_call_after_excl(p: &mut Parser) -> BlockLike {
pub(super) fn macro_call_after_excl(p: &mut Parser<'_>) -> BlockLike {
p.expect(T![!]);
match p.current() {
@ -439,7 +439,7 @@ pub(super) fn macro_call_after_excl(p: &mut Parser) -> BlockLike {
}
}
pub(crate) fn token_tree(p: &mut Parser) {
pub(crate) fn token_tree(p: &mut Parser<'_>) {
let closing_paren_kind = match p.current() {
T!['{'] => T!['}'],
T!['('] => T![')'],

18
crates/parser/src/grammar/items/adt.rs
View file

@ -2,20 +2,20 @@ use super::*;
// test struct_item
// struct S {}
pub(super) fn strukt(p: &mut Parser, m: Marker) {
pub(super) fn strukt(p: &mut Parser<'_>, m: Marker) {
p.bump(T![struct]);
struct_or_union(p, m, true);
}
// test union_item
// struct U { i: i32, f: f32 }
pub(super) fn union(p: &mut Parser, m: Marker) {
pub(super) fn union(p: &mut Parser<'_>, m: Marker) {
assert!(p.at_contextual_kw(T![union]));
p.bump_remap(T![union]);
struct_or_union(p, m, false);
}
fn struct_or_union(p: &mut Parser, m: Marker, is_struct: bool) {
fn struct_or_union(p: &mut Parser<'_>, m: Marker, is_struct: bool) {
name_r(p, ITEM_RECOVERY_SET);
generic_params::opt_generic_param_list(p);
match p.current() {
@ -50,7 +50,7 @@ fn struct_or_union(p: &mut Parser, m: Marker, is_struct: bool) {
m.complete(p, if is_struct { STRUCT } else { UNION });
}
pub(super) fn enum_(p: &mut Parser, m: Marker) {
pub(super) fn enum_(p: &mut Parser<'_>, m: Marker) {
p.bump(T![enum]);
name_r(p, ITEM_RECOVERY_SET);
generic_params::opt_generic_param_list(p);
@ -63,7 +63,7 @@ pub(super) fn enum_(p: &mut Parser, m: Marker) {
m.complete(p, ENUM);
}
pub(crate) fn variant_list(p: &mut Parser) {
pub(crate) fn variant_list(p: &mut Parser<'_>) {
assert!(p.at(T!['{']));
let m = p.start();
p.bump(T!['{']);
@ -80,7 +80,7 @@ pub(crate) fn variant_list(p: &mut Parser) {
p.expect(T!['}']);
m.complete(p, VARIANT_LIST);
fn variant(p: &mut Parser) {
fn variant(p: &mut Parser<'_>) {
let m = p.start();
attributes::outer_attrs(p);
if p.at(IDENT) {
@ -106,7 +106,7 @@ pub(crate) fn variant_list(p: &mut Parser) {
// test record_field_list
// struct S { a: i32, b: f32 }
pub(crate) fn record_field_list(p: &mut Parser) {
pub(crate) fn record_field_list(p: &mut Parser<'_>) {
assert!(p.at(T!['{']));
let m = p.start();
p.bump(T!['{']);
@ -123,7 +123,7 @@ pub(crate) fn record_field_list(p: &mut Parser) {
p.expect(T!['}']);
m.complete(p, RECORD_FIELD_LIST);
fn record_field(p: &mut Parser) {
fn record_field(p: &mut Parser<'_>) {
let m = p.start();
// test record_field_attrs
// struct S { #[attr] f: f32 }
@ -141,7 +141,7 @@ pub(crate) fn record_field_list(p: &mut Parser) {
}
}
fn tuple_field_list(p: &mut Parser) {
fn tuple_field_list(p: &mut Parser<'_>) {
assert!(p.at(T!['(']));
let m = p.start();
p.bump(T!['(']);

6
crates/parser/src/grammar/items/consts.rs
View file

@ -2,17 +2,17 @@ use super::*;
// test const_item
// const C: u32 = 92;
pub(super) fn konst(p: &mut Parser, m: Marker) {
pub(super) fn konst(p: &mut Parser<'_>, m: Marker) {
p.bump(T![const]);
const_or_static(p, m, true);
}
pub(super) fn static_(p: &mut Parser, m: Marker) {
pub(super) fn static_(p: &mut Parser<'_>, m: Marker) {
p.bump(T![static]);
const_or_static(p, m, false);
}
fn const_or_static(p: &mut Parser, m: Marker, is_const: bool) {
fn const_or_static(p: &mut Parser<'_>, m: Marker, is_const: bool) {
p.eat(T![mut]);
if is_const && p.eat(T![_]) {

10
crates/parser/src/grammar/items/traits.rs
View file

@ -2,7 +2,7 @@ use super::*;
// test trait_item
// trait T { fn new() -> Self; }
pub(super) fn trait_(p: &mut Parser, m: Marker) {
pub(super) fn trait_(p: &mut Parser<'_>, m: Marker) {
p.bump(T![trait]);
name_r(p, ITEM_RECOVERY_SET);
@ -44,7 +44,7 @@ pub(super) fn trait_(p: &mut Parser, m: Marker) {
// test impl_item
// impl S {}
pub(super) fn impl_(p: &mut Parser, m: Marker) {
pub(super) fn impl_(p: &mut Parser<'_>, m: Marker) {
p.bump(T![impl]);
if p.at(T![<]) && not_a_qualified_path(p) {
generic_params::opt_generic_param_list(p);
@ -80,7 +80,7 @@ pub(super) fn impl_(p: &mut Parser, m: Marker) {
// fn foo() {}
// fn bar(&self) {}
// }
pub(crate) fn assoc_item_list(p: &mut Parser) {
pub(crate) fn assoc_item_list(p: &mut Parser<'_>) {
assert!(p.at(T!['{']));
let m = p.start();
@ -102,7 +102,7 @@ pub(crate) fn assoc_item_list(p: &mut Parser) {
// test impl_type_params
// impl<const N: u32> Bar<N> {}
fn not_a_qualified_path(p: &Parser) -> bool {
fn not_a_qualified_path(p: &Parser<'_>) -> bool {
// There's an ambiguity between generic parameters and qualified paths in impls.
// If we see `<` it may start both, so we have to inspect some following tokens.
// The following combinations can only start generics,
@ -131,7 +131,7 @@ fn not_a_qualified_path(p: &Parser) -> bool {
// impl Trait1 for T {}
// impl impl NotType {}
// impl Trait2 for impl NotType {}
pub(crate) fn impl_type(p: &mut Parser) {
pub(crate) fn impl_type(p: &mut Parser<'_>) {
if p.at(T![impl]) {
p.error("expected trait or type");
return;

6
crates/parser/src/grammar/items/use_item.rs
View file

@ -2,7 +2,7 @@ use super::*;
// test use_item
// use std::collections;
pub(super) fn use_(p: &mut Parser, m: Marker) {
pub(super) fn use_(p: &mut Parser<'_>, m: Marker) {
p.bump(T![use]);
use_tree(p, true);
p.expect(T![;]);
@ -11,7 +11,7 @@ pub(super) fn use_(p: &mut Parser, m: Marker) {
// test use_tree
// use outer::tree::{inner::tree};
fn use_tree(p: &mut Parser, top_level: bool) {
fn use_tree(p: &mut Parser<'_>, top_level: bool) {
let m = p.start();
match p.current() {
// test use_tree_star
@ -78,7 +78,7 @@ fn use_tree(p: &mut Parser, top_level: bool) {
// test use_tree_list
// use {a, b, c};
pub(crate) fn use_tree_list(p: &mut Parser) {
pub(crate) fn use_tree_list(p: &mut Parser<'_>) {
assert!(p.at(T!['{']));
let m = p.start();
p.bump(T!['{']);

18
crates/parser/src/grammar/params.rs
View file

@ -5,21 +5,21 @@ use super::*;
// fn b(x: i32) {}
// fn c(x: i32, ) {}
// fn d(x: i32, y: ()) {}
pub(super) fn param_list_fn_def(p: &mut Parser) {
pub(super) fn param_list_fn_def(p: &mut Parser<'_>) {
list_(p, Flavor::FnDef);
}
// test param_list_opt_patterns
// fn foo<F: FnMut(&mut Foo<'a>)>(){}
pub(super) fn param_list_fn_trait(p: &mut Parser) {
pub(super) fn param_list_fn_trait(p: &mut Parser<'_>) {
list_(p, Flavor::FnTrait);
}
pub(super) fn param_list_fn_ptr(p: &mut Parser) {
pub(super) fn param_list_fn_ptr(p: &mut Parser<'_>) {
list_(p, Flavor::FnPointer);
}
pub(super) fn param_list_closure(p: &mut Parser) {
pub(super) fn param_list_closure(p: &mut Parser<'_>) {
list_(p, Flavor::Closure);
}
@ -31,7 +31,7 @@ enum Flavor {
Closure,
}
fn list_(p: &mut Parser, flavor: Flavor) {
fn list_(p: &mut Parser<'_>, flavor: Flavor) {
use Flavor::*;
let (bra, ket) = match flavor {
@ -87,7 +87,7 @@ fn list_(p: &mut Parser, flavor: Flavor) {
const PARAM_FIRST: TokenSet = patterns::PATTERN_FIRST.union(types::TYPE_FIRST);
fn param(p: &mut Parser, m: Marker, flavor: Flavor) {
fn param(p: &mut Parser<'_>, m: Marker, flavor: Flavor) {
match flavor {
// test param_list_vararg
// extern "C" { fn printf(format: *const i8, ..., _: u8) -> i32; }
@ -146,7 +146,7 @@ fn param(p: &mut Parser, m: Marker, flavor: Flavor) {
m.complete(p, PARAM);
}
fn variadic_param(p: &mut Parser) -> bool {
fn variadic_param(p: &mut Parser<'_>) -> bool {
if p.at(T![:]) && p.nth_at(1, T![...]) {
p.bump(T![:]);
p.bump(T![...]);
@ -164,7 +164,7 @@ fn variadic_param(p: &mut Parser) -> bool {
// fn d(&'a mut self, x: i32) {}
// fn e(mut self) {}
// }
fn opt_self_param(p: &mut Parser, m: Marker) -> Result<(), Marker> {
fn opt_self_param(p: &mut Parser<'_>, m: Marker) -> Result<(), Marker> {
if p.at(T![self]) || p.at(T![mut]) && p.nth(1) == T![self] {
p.eat(T![mut]);
self_as_name(p);
@ -202,7 +202,7 @@ fn opt_self_param(p: &mut Parser, m: Marker) -> Result<(), Marker> {
Ok(())
}
fn self_as_name(p: &mut Parser) {
fn self_as_name(p: &mut Parser<'_>) {
let m = p.start();
p.bump(T![self]);
m.complete(p, NAME);

20
crates/parser/src/grammar/paths.rs
View file

@ -3,11 +3,11 @@ use super::*;
pub(super) const PATH_FIRST: TokenSet =
TokenSet::new(&[IDENT, T![self], T![super], T![crate], T![Self], T![:], T![<]]);
pub(super) fn is_path_start(p: &Parser) -> bool {
pub(super) fn is_path_start(p: &Parser<'_>) -> bool {
is_use_path_start(p) || p.at(T![<]) || p.at(T![Self])
}
pub(super) fn is_use_path_start(p: &Parser) -> bool {
pub(super) fn is_use_path_start(p: &Parser<'_>) -> bool {
match p.current() {
IDENT | T![self] | T![super] | T![crate] => true,
T![:] if p.at(T![::]) => true,
@ -15,19 +15,19 @@ pub(super) fn is_use_path_start(p: &Parser) -> bool {
}
}
pub(super) fn use_path(p: &mut Parser) {
pub(super) fn use_path(p: &mut Parser<'_>) {
path(p, Mode::Use);
}
pub(crate) fn type_path(p: &mut Parser) {
pub(crate) fn type_path(p: &mut Parser<'_>) {
path(p, Mode::Type);
}
pub(super) fn expr_path(p: &mut Parser) {
pub(super) fn expr_path(p: &mut Parser<'_>) {
path(p, Mode::Expr);
}
pub(crate) fn type_path_for_qualifier(p: &mut Parser, qual: CompletedMarker) -> CompletedMarker {
pub(crate) fn type_path_for_qualifier(p: &mut Parser<'_>, qual: CompletedMarker) -> CompletedMarker {
path_for_qualifier(p, Mode::Type, qual)
}
@ -38,14 +38,14 @@ enum Mode {
Expr,
}
fn path(p: &mut Parser, mode: Mode) {
fn path(p: &mut Parser<'_>, mode: Mode) {
let path = p.start();
path_segment(p, mode, true);
let qual = path.complete(p, PATH);
path_for_qualifier(p, mode, qual);
}
fn path_for_qualifier(p: &mut Parser, mode: Mode, mut qual: CompletedMarker) -> CompletedMarker {
fn path_for_qualifier(p: &mut Parser<'_>, mode: Mode, mut qual: CompletedMarker) -> CompletedMarker {
loop {
let use_tree = matches!(p.nth(2), T![*] | T!['{']);
if p.at(T![::]) && !use_tree {
@ -60,7 +60,7 @@ fn path_for_qualifier(p: &mut Parser, mode: Mode, mut qual: CompletedMarker) ->
}
}
fn path_segment(p: &mut Parser, mode: Mode, first: bool) {
fn path_segment(p: &mut Parser<'_>, mode: Mode, first: bool) {
let m = p.start();
// test qual_paths
// type X = <A as B>::Output;
@ -107,7 +107,7 @@ fn path_segment(p: &mut Parser, mode: Mode, first: bool) {
m.complete(p, PATH_SEGMENT);
}
fn opt_path_type_args(p: &mut Parser, mode: Mode) {
fn opt_path_type_args(p: &mut Parser<'_>, mode: Mode) {
match mode {
Mode::Use => {}
Mode::Type => {

44
crates/parser/src/grammar/patterns.rs
View file

@ -13,22 +13,22 @@ pub(super) const PATTERN_FIRST: TokenSet =
T![.],
]));
pub(crate) fn pattern(p: &mut Parser) {
pub(crate) fn pattern(p: &mut Parser<'_>) {
pattern_r(p, PAT_RECOVERY_SET);
}
/// Parses a pattern list separated by pipes `|`.
pub(super) fn pattern_top(p: &mut Parser) {
pub(super) fn pattern_top(p: &mut Parser<'_>) {
pattern_top_r(p, PAT_RECOVERY_SET);
}
pub(crate) fn pattern_single(p: &mut Parser) {
pub(crate) fn pattern_single(p: &mut Parser<'_>) {
pattern_single_r(p, PAT_RECOVERY_SET);
}
/// Parses a pattern list separated by pipes `|`
/// using the given `recovery_set`.
pub(super) fn pattern_top_r(p: &mut Parser, recovery_set: TokenSet) {
pub(super) fn pattern_top_r(p: &mut Parser<'_>, recovery_set: TokenSet) {
p.eat(T![|]);
pattern_r(p, recovery_set);
}
@ -45,7 +45,7 @@ pub(super) fn pattern_top_r(p: &mut Parser, recovery_set: TokenSet) {
// [_ | _,] => (),
// }
// }
fn pattern_r(p: &mut Parser, recovery_set: TokenSet) {
fn pattern_r(p: &mut Parser<'_>, recovery_set: TokenSet) {
let m = p.start();
pattern_single_r(p, recovery_set);
@ -59,7 +59,7 @@ fn pattern_r(p: &mut Parser, recovery_set: TokenSet) {
m.complete(p, OR_PAT);
}
fn pattern_single_r(p: &mut Parser, recovery_set: TokenSet) {
fn pattern_single_r(p: &mut Parser<'_>, recovery_set: TokenSet) {
if let Some(lhs) = atom_pat(p, recovery_set) {
// test range_pat
// fn main() {
@ -106,7 +106,7 @@ fn pattern_single_r(p: &mut Parser, recovery_set: TokenSet) {
const PAT_RECOVERY_SET: TokenSet =
TokenSet::new(&[T![let], T![if], T![while], T![loop], T![match], T![')'], T![,], T![=]]);
fn atom_pat(p: &mut Parser, recovery_set: TokenSet) -> Option<CompletedMarker> {
fn atom_pat(p: &mut Parser<'_>, recovery_set: TokenSet) -> Option<CompletedMarker> {
let m = match p.current() {
T![box] => box_pat(p),
T![ref] | T![mut] => ident_pat(p, true),
@ -139,7 +139,7 @@ fn atom_pat(p: &mut Parser, recovery_set: TokenSet) -> Option<CompletedMarker> {
Some(m)
}
fn is_literal_pat_start(p: &Parser) -> bool {
fn is_literal_pat_start(p: &Parser<'_>) -> bool {
p.at(T![-]) && (p.nth(1) == INT_NUMBER || p.nth(1) == FLOAT_NUMBER)
|| p.at_ts(expressions::LITERAL_FIRST)
}
@ -153,7 +153,7 @@ fn is_literal_pat_start(p: &Parser) -> bool {
// "hello" => (),
// }
// }
fn literal_pat(p: &mut Parser) -> CompletedMarker {
fn literal_pat(p: &mut Parser<'_>) -> CompletedMarker {
assert!(is_literal_pat_start(p));
let m = p.start();
if p.at(T![-]) {
@ -170,7 +170,7 @@ fn literal_pat(p: &mut Parser) -> CompletedMarker {
// let Bar { .. } = ();
// let Bar(..) = ();
// }
fn path_or_macro_pat(p: &mut Parser) -> CompletedMarker {
fn path_or_macro_pat(p: &mut Parser<'_>) -> CompletedMarker {
assert!(paths::is_path_start(p));
let m = p.start();
paths::expr_path(p);
@ -203,7 +203,7 @@ fn path_or_macro_pat(p: &mut Parser) -> CompletedMarker {
// let S(_,) = ();
// let S(_, .. , x) = ();
// }
fn tuple_pat_fields(p: &mut Parser) {
fn tuple_pat_fields(p: &mut Parser<'_>) {
assert!(p.at(T!['(']));
p.bump(T!['(']);
pat_list(p, T![')']);
@ -216,7 +216,7 @@ fn tuple_pat_fields(p: &mut Parser) {
// let S { x: 1 } = ();
// let S { #[cfg(any())] x: 1 } = ();
// }
fn record_pat_field(p: &mut Parser) {
fn record_pat_field(p: &mut Parser<'_>) {
match p.current() {
IDENT | INT_NUMBER if p.nth(1) == T![:] => {
name_ref_or_index(p);
@ -244,7 +244,7 @@ fn record_pat_field(p: &mut Parser) {
// let S { h: _, } = ();
// let S { #[cfg(any())] .. } = ();
// }
fn record_pat_field_list(p: &mut Parser) {
fn record_pat_field_list(p: &mut Parser<'_>) {
assert!(p.at(T!['{']));
let m = p.start();
p.bump(T!['{']);
@ -277,7 +277,7 @@ fn record_pat_field_list(p: &mut Parser) {
// test placeholder_pat
// fn main() { let _ = (); }
fn wildcard_pat(p: &mut Parser) -> CompletedMarker {
fn wildcard_pat(p: &mut Parser<'_>) -> CompletedMarker {
assert!(p.at(T![_]));
let m = p.start();
p.bump(T![_]);
@ -310,7 +310,7 @@ fn wildcard_pat(p: &mut Parser) -> CompletedMarker {
// let [head, .., mid, tail @ ..] = ();
// let [head, .., mid, .., cons] = ();
// }
fn rest_pat(p: &mut Parser) -> CompletedMarker {
fn rest_pat(p: &mut Parser<'_>) -> CompletedMarker {
assert!(p.at(T![..]));
let m = p.start();
p.bump(T![..]);
@ -322,7 +322,7 @@ fn rest_pat(p: &mut Parser) -> CompletedMarker {
// let &a = ();
// let &mut b = ();
// }
fn ref_pat(p: &mut Parser) -> CompletedMarker {
fn ref_pat(p: &mut Parser<'_>) -> CompletedMarker {
assert!(p.at(T![&]));
let m = p.start();
p.bump(T![&]);
@ -338,7 +338,7 @@ fn ref_pat(p: &mut Parser) -> CompletedMarker {
// let (..) = ();
// let () = ();
// }
fn tuple_pat(p: &mut Parser) -> CompletedMarker {
fn tuple_pat(p: &mut Parser<'_>) -> CompletedMarker {
assert!(p.at(T!['(']));
let m = p.start();
p.bump(T!['(']);
@ -368,7 +368,7 @@ fn tuple_pat(p: &mut Parser) -> CompletedMarker {
// fn main() {
// let [a, b, ..] = [];
// }
fn slice_pat(p: &mut Parser) -> CompletedMarker {
fn slice_pat(p: &mut Parser<'_>) -> CompletedMarker {
assert!(p.at(T!['[']));
let m = p.start();
p.bump(T!['[']);
@ -377,7 +377,7 @@ fn slice_pat(p: &mut Parser) -> CompletedMarker {
m.complete(p, SLICE_PAT)
}
fn pat_list(p: &mut Parser, ket: SyntaxKind) {
fn pat_list(p: &mut Parser<'_>, ket: SyntaxKind) {
while !p.at(EOF) && !p.at(ket) {
if !p.at_ts(PATTERN_FIRST) {
p.error("expected a pattern");
@ -400,7 +400,7 @@ fn pat_list(p: &mut Parser, ket: SyntaxKind) {
// let e @ _ = ();
// let ref mut f @ g @ _ = ();
// }
fn ident_pat(p: &mut Parser, with_at: bool) -> CompletedMarker {
fn ident_pat(p: &mut Parser<'_>, with_at: bool) -> CompletedMarker {
assert!(matches!(p.current(), T![ref] | T![mut] | IDENT));
let m = p.start();
p.eat(T![ref]);
@ -418,7 +418,7 @@ fn ident_pat(p: &mut Parser, with_at: bool) -> CompletedMarker {
// let box Outer { box i, j: box Inner(box &x) } = ();
// let box ref mut i = ();
// }
fn box_pat(p: &mut Parser) -> CompletedMarker {
fn box_pat(p: &mut Parser<'_>) -> CompletedMarker {
assert!(p.at(T![box]));
let m = p.start();
p.bump(T![box]);
@ -431,7 +431,7 @@ fn box_pat(p: &mut Parser) -> CompletedMarker {
// let const { 15 } = ();
// let const { foo(); bar() } = ();
// }
fn const_block_pat(p: &mut Parser) -> CompletedMarker {
fn const_block_pat(p: &mut Parser<'_>) -> CompletedMarker {
assert!(p.at(T![const]));
let m = p.start();
p.bump(T![const]);

38
crates/parser/src/grammar/types.rs
View file

@ -25,15 +25,15 @@ const TYPE_RECOVERY_SET: TokenSet = TokenSet::new(&[
T![pub],
]);
pub(crate) fn type_(p: &mut Parser) {
pub(crate) fn type_(p: &mut Parser<'_>) {
type_with_bounds_cond(p, true);
}
pub(super) fn type_no_bounds(p: &mut Parser) {
pub(super) fn type_no_bounds(p: &mut Parser<'_>) {
type_with_bounds_cond(p, false);
}
fn type_with_bounds_cond(p: &mut Parser, allow_bounds: bool) {
fn type_with_bounds_cond(p: &mut Parser<'_>, allow_bounds: bool) {
match p.current() {
T!['('] => paren_or_tuple_type(p),
T![!] => never_type(p),
@ -54,7 +54,7 @@ fn type_with_bounds_cond(p: &mut Parser, allow_bounds: bool) {
}
}
pub(super) fn ascription(p: &mut Parser) {
pub(super) fn ascription(p: &mut Parser<'_>) {
assert!(p.at(T![:]));
p.bump(T![:]);
if p.at(T![=]) {
@ -66,7 +66,7 @@ pub(super) fn ascription(p: &mut Parser) {
type_(p);
}
fn paren_or_tuple_type(p: &mut Parser) {
fn paren_or_tuple_type(p: &mut Parser<'_>) {
assert!(p.at(T!['(']));
let m = p.start();
p.bump(T!['(']);
@ -101,14 +101,14 @@ fn paren_or_tuple_type(p: &mut Parser) {
// test never_type
// type Never = !;
fn never_type(p: &mut Parser) {
fn never_type(p: &mut Parser<'_>) {
assert!(p.at(T![!]));
let m = p.start();
p.bump(T![!]);
m.complete(p, NEVER_TYPE);
}
fn ptr_type(p: &mut Parser) {
fn ptr_type(p: &mut Parser<'_>) {
assert!(p.at(T![*]));
let m = p.start();
p.bump(T![*]);
@ -132,7 +132,7 @@ fn ptr_type(p: &mut Parser) {
m.complete(p, PTR_TYPE);
}
fn array_or_slice_type(p: &mut Parser) {
fn array_or_slice_type(p: &mut Parser<'_>) {
assert!(p.at(T!['[']));
let m = p.start();
p.bump(T!['[']);
@ -168,7 +168,7 @@ fn array_or_slice_type(p: &mut Parser) {
// type A = &();
// type B = &'static ();
// type C = &mut ();
fn ref_type(p: &mut Parser) {
fn ref_type(p: &mut Parser<'_>) {
assert!(p.at(T![&]));
let m = p.start();
p.bump(T![&]);
@ -182,7 +182,7 @@ fn ref_type(p: &mut Parser) {
// test placeholder_type
// type Placeholder = _;
fn infer_type(p: &mut Parser) {
fn infer_type(p: &mut Parser<'_>) {
assert!(p.at(T![_]));
let m = p.start();
p.bump(T![_]);
@ -194,7 +194,7 @@ fn infer_type(p: &mut Parser) {
// type B = unsafe fn();
// type C = unsafe extern "C" fn();
// type D = extern "C" fn ( u8 , ... ) -> u8;
fn fn_ptr_type(p: &mut Parser) {
fn fn_ptr_type(p: &mut Parser<'_>) {
let m = p.start();
p.eat(T![unsafe]);
if p.at(T![extern]) {
@ -218,7 +218,7 @@ fn fn_ptr_type(p: &mut Parser) {
m.complete(p, FN_PTR_TYPE);
}
pub(super) fn for_binder(p: &mut Parser) {
pub(super) fn for_binder(p: &mut Parser<'_>) {
assert!(p.at(T![for]));
p.bump(T![for]);
if p.at(T![<]) {
@ -232,7 +232,7 @@ pub(super) fn for_binder(p: &mut Parser) {
// type A = for<'a> fn() -> ();
// type B = for<'a> unsafe extern "C" fn(&'a ()) -> ();
// type Obj = for<'a> PartialEq<&'a i32>;
pub(super) fn for_type(p: &mut Parser, allow_bounds: bool) {
pub(super) fn for_type(p: &mut Parser<'_>, allow_bounds: bool) {
assert!(p.at(T![for]));
let m = p.start();
for_binder(p);
@ -256,7 +256,7 @@ pub(super) fn for_type(p: &mut Parser, allow_bounds: bool) {
// test impl_trait_type
// type A = impl Iterator<Item=Foo<'a>> + 'a;
fn impl_trait_type(p: &mut Parser) {
fn impl_trait_type(p: &mut Parser<'_>) {
assert!(p.at(T![impl]));
let m = p.start();
p.bump(T![impl]);
@ -266,7 +266,7 @@ fn impl_trait_type(p: &mut Parser) {
// test dyn_trait_type
// type A = dyn Iterator<Item=Foo<'a>> + 'a;
fn dyn_trait_type(p: &mut Parser) {
fn dyn_trait_type(p: &mut Parser<'_>) {
assert!(p.at(T![dyn]));
let m = p.start();
p.bump(T![dyn]);
@ -279,14 +279,14 @@ fn dyn_trait_type(p: &mut Parser) {
// type B = ::Foo;
// type C = self::Foo;
// type D = super::Foo;
pub(super) fn path_type(p: &mut Parser) {
pub(super) fn path_type(p: &mut Parser<'_>) {
path_type_(p, true);
}
// test macro_call_type
// type A = foo!();
// type B = crate::foo!();
fn path_or_macro_type_(p: &mut Parser, allow_bounds: bool) {
fn path_or_macro_type_(p: &mut Parser<'_>, allow_bounds: bool) {
assert!(paths::is_path_start(p));
let r = p.start();
let m = p.start();
@ -309,7 +309,7 @@ fn path_or_macro_type_(p: &mut Parser, allow_bounds: bool) {
}
}
pub(super) fn path_type_(p: &mut Parser, allow_bounds: bool) {
pub(super) fn path_type_(p: &mut Parser<'_>, allow_bounds: bool) {
assert!(paths::is_path_start(p));
let m = p.start();
paths::type_path(p);
@ -325,7 +325,7 @@ pub(super) fn path_type_(p: &mut Parser, allow_bounds: bool) {
/// This turns a parsed PATH_TYPE or FOR_TYPE optionally into a DYN_TRAIT_TYPE
/// with a TYPE_BOUND_LIST
fn opt_type_bounds_as_dyn_trait_type(p: &mut Parser, type_marker: CompletedMarker) {
fn opt_type_bounds_as_dyn_trait_type(p: &mut Parser<'_>, type_marker: CompletedMarker) {
assert!(matches!(
type_marker.kind(),
SyntaxKind::PATH_TYPE | SyntaxKind::FOR_TYPE | SyntaxKind::MACRO_TYPE

6
crates/parser/src/lib.rs
View file

@ -79,7 +79,7 @@ pub enum TopEntryPoint {
impl TopEntryPoint {
pub fn parse(&self, input: &Input) -> Output {
let entry_point: fn(&'_ mut parser::Parser) = match self {
let entry_point: fn(&'_ mut parser::Parser<'_>) = match self {
TopEntryPoint::SourceFile => grammar::entry::top::source_file,
TopEntryPoint::MacroStmts => grammar::entry::top::macro_stmts,
TopEntryPoint::MacroItems => grammar::entry::top::macro_items,
@ -136,7 +136,7 @@ pub enum PrefixEntryPoint {
impl PrefixEntryPoint {
pub fn parse(&self, input: &Input) -> Output {
let entry_point: fn(&'_ mut parser::Parser) = match self {
let entry_point: fn(&'_ mut parser::Parser<'_>) = match self {
PrefixEntryPoint::Vis => grammar::entry::prefix::vis,
PrefixEntryPoint::Block => grammar::entry::prefix::block,
PrefixEntryPoint::Stmt => grammar::entry::prefix::stmt,
@ -155,7 +155,7 @@ impl PrefixEntryPoint {
}
/// A parsing function for a specific braced-block.
pub struct Reparser(fn(&mut parser::Parser));
pub struct Reparser(fn(&mut parser::Parser<'_>));
impl Reparser {
/// If the node is a braced block, return the corresponding `Reparser`.

8
crates/parser/src/parser.rs
View file

@ -259,7 +259,7 @@ impl Marker {
/// Finishes the syntax tree node and assigns `kind` to it,
/// and mark the create a `CompletedMarker` for possible future
/// operation like `.precede()` to deal with forward_parent.
pub(crate) fn complete(mut self, p: &mut Parser, kind: SyntaxKind) -> CompletedMarker {
pub(crate) fn complete(mut self, p: &mut Parser<'_>, kind: SyntaxKind) -> CompletedMarker {
self.bomb.defuse();
let idx = self.pos as usize;
match &mut p.events[idx] {
@ -274,7 +274,7 @@ impl Marker {
/// Abandons the syntax tree node. All its children
/// are attached to its parent instead.
pub(crate) fn abandon(mut self, p: &mut Parser) {
pub(crate) fn abandon(mut self, p: &mut Parser<'_>) {
self.bomb.defuse();
let idx = self.pos as usize;
if idx == p.events.len() - 1 {
@ -309,7 +309,7 @@ impl CompletedMarker {
/// Append a new `START` events as `[START, FINISH, NEWSTART]`,
/// then mark `NEWSTART` as `START`'s parent with saving its relative
/// distance to `NEWSTART` into forward_parent(=2 in this case);
pub(crate) fn precede(self, p: &mut Parser) -> Marker {
pub(crate) fn precede(self, p: &mut Parser<'_>) -> Marker {
let new_pos = p.start();
let idx = self.pos as usize;
match &mut p.events[idx] {
@ -322,7 +322,7 @@ impl CompletedMarker {
}
/// Extends this completed marker *to the left* up to `m`.
pub(crate) fn extend_to(self, p: &mut Parser, mut m: Marker) -> CompletedMarker {
pub(crate) fn extend_to(self, p: &mut Parser<'_>, mut m: Marker) -> CompletedMarker {
m.bomb.defuse();
let idx = m.pos as usize;
match &mut p.events[idx] {

2
crates/parser/src/shortcuts.rs
View file

@ -54,7 +54,7 @@ impl<'a> LexedStr<'a> {
pub fn intersperse_trivia(
&self,
output: &crate::Output,
sink: &mut dyn FnMut(StrStep),
sink: &mut dyn FnMut(StrStep<'_>),
) -> bool {
let mut builder = Builder { lexed: self, pos: 0, state: State::PendingEnter, sink };