Mirrors/rust-analyzer
2
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer synced 2024-12-26 04:53:34 +00:00
Code Issues Projects Releases Packages Wiki Activity

Align parser names with grammar

Browse source
This commit is contained in:
Aleksey Kladov 2020-08-13 17:58:35 +02:00
parent 1b0c7701cc
commit 6bc2633c90
17 changed files with 124 additions and 223 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -142,19 +142,19 @@ pub(crate) fn reparser(
) -> Option<fn(&mut Parser)> { ) -> Option<fn(&mut Parser)> {
let res = match node { let res = match node {
BLOCK_EXPR => expressions::block_expr, BLOCK_EXPR => expressions::block_expr,
RECORD_FIELD_LIST => items::record_field_def_list, RECORD_FIELD_LIST => items::record_field_list,
RECORD_EXPR_FIELD_LIST => items::record_field_list, RECORD_EXPR_FIELD_LIST => items::record_expr_field_list,
VARIANT_LIST => items::enum_variant_list, VARIANT_LIST => items::variant_list,
MATCH_ARM_LIST => items::match_arm_list, MATCH_ARM_LIST => items::match_arm_list,
USE_TREE_LIST => items::use_tree_list, USE_TREE_LIST => items::use_tree_list,
EXTERN_ITEM_LIST => items::extern_item_list, EXTERN_ITEM_LIST => items::extern_item_list,
TOKEN_TREE if first_child? == T!['{'] => items::token_tree, TOKEN_TREE if first_child? == T!['{'] => items::token_tree,
ASSOC_ITEM_LIST => match parent? { ASSOC_ITEM_LIST => match parent? {
IMPL => items::impl_item_list, IMPL => items::assoc_item_list,
TRAIT => items::trait_item_list, TRAIT => items::assoc_item_list,
_ => return None, _ => return None,
}, },
ITEM_LIST => items::mod_item_list, ITEM_LIST => items::item_list,
_ => return None, _ => return None,
}; };
Some(res) Some(res)
@ -217,7 +217,7 @@ fn opt_visibility(p: &mut Parser) -> bool {
true true
} }
fn opt_alias(p: &mut Parser) { fn opt_rename(p: &mut Parser) {
if p.at(T![as]) { if p.at(T![as]) {
let m = p.start(); let m = p.start();
p.bump(T![as]); p.bump(T![as]);
@ -239,7 +239,7 @@ fn abi(p: &mut Parser) {
abi.complete(p, ABI); abi.complete(p, ABI);
} }
fn opt_fn_ret_type(p: &mut Parser) -> bool { fn opt_ret_type(p: &mut Parser) -> bool {
if p.at(T![->]) { if p.at(T![->]) {
let m = p.start(); let m = p.start();
p.bump(T![->]); p.bump(T![->]);

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

@ -2,19 +2,19 @@
use super::*; use super::*;
pub(super) fn inner_attributes(p: &mut Parser) { pub(super) fn inner_attrs(p: &mut Parser) {
while p.at(T![#]) && p.nth(1) == T![!] { while p.at(T![#]) && p.nth(1) == T![!] {
attribute(p, true) attr(p, true)
} }
} }
pub(super) fn outer_attributes(p: &mut Parser) { pub(super) fn outer_attrs(p: &mut Parser) {
while p.at(T![#]) { while p.at(T![#]) {
attribute(p, false) attr(p, false)
} }
} }
fn attribute(p: &mut Parser, inner: bool) { fn attr(p: &mut Parser, inner: bool) {
let attr = p.start(); let attr = p.start();
assert!(p.at(T![#])); assert!(p.at(T![#]));
p.bump(T![#]); p.bump(T![#]);

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

@ -22,7 +22,7 @@ pub(super) fn expr(p: &mut Parser) -> (Option<CompletedMarker>, BlockLike) {
pub(super) fn expr_with_attrs(p: &mut Parser) -> bool { pub(super) fn expr_with_attrs(p: &mut Parser) -> bool {
let m = p.start(); let m = p.start();
let has_attrs = p.at(T![#]); let has_attrs = p.at(T![#]);
attributes::outer_attributes(p); attributes::outer_attrs(p);
let (cm, _block_like) = expr(p); let (cm, _block_like) = expr(p);
let success = cm.is_some(); let success = cm.is_some();
@ -64,7 +64,7 @@ pub(super) fn stmt(p: &mut Parser, with_semi: StmtWithSemi) {
// #[D] return (); // #[D] return ();
// } // }
let has_attrs = p.at(T![#]); let has_attrs = p.at(T![#]);
attributes::outer_attributes(p); attributes::outer_attrs(p);
if p.at(T![let]) { if p.at(T![let]) {
let_stmt(p, m, with_semi); let_stmt(p, m, with_semi);
@ -175,7 +175,7 @@ pub(super) fn stmt(p: &mut Parser, with_semi: StmtWithSemi) {
pub(super) fn expr_block_contents(p: &mut Parser) { pub(super) fn expr_block_contents(p: &mut Parser) {
// This is checked by a validator // This is checked by a validator
attributes::inner_attributes(p); attributes::inner_attrs(p);
while !p.at(EOF) && !p.at(T!['}']) { while !p.at(EOF) && !p.at(T!['}']) {
// test nocontentexpr // test nocontentexpr
@ -489,7 +489,7 @@ fn method_call_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
let m = lhs.precede(p); let m = lhs.precede(p);
p.bump_any(); p.bump_any();
name_ref(p); name_ref(p);
type_args::opt_type_arg_list(p, true); type_args::opt_generic_arg_list(p, true);
if p.at(T!['(']) { if p.at(T!['(']) {
arg_list(p); arg_list(p);
} }
@ -585,7 +585,7 @@ fn path_expr(p: &mut Parser, r: Restrictions) -> (CompletedMarker, BlockLike) {
paths::expr_path(p); paths::expr_path(p);
match p.current() { match p.current() {
T!['{'] if !r.forbid_structs => { T!['{'] if !r.forbid_structs => {
record_field_list(p); record_expr_field_list(p);
(m.complete(p, RECORD_EXPR), BlockLike::NotBlock) (m.complete(p, RECORD_EXPR), BlockLike::NotBlock)
} }
T![!] if !p.at(T![!=]) => { T![!] if !p.at(T![!=]) => {
@ -603,7 +603,7 @@ fn path_expr(p: &mut Parser, r: Restrictions) -> (CompletedMarker, BlockLike) {
// S { x, y: 32, ..Default::default() }; // S { x, y: 32, ..Default::default() };
// TupleStruct { 0: 1 }; // TupleStruct { 0: 1 };
// } // }
pub(crate) fn record_field_list(p: &mut Parser) { pub(crate) fn record_expr_field_list(p: &mut Parser) {
assert!(p.at(T!['{'])); assert!(p.at(T!['{']));
let m = p.start(); let m = p.start();
p.bump(T!['{']); p.bump(T!['{']);
@ -613,7 +613,7 @@ pub(crate) fn record_field_list(p: &mut Parser) {
// fn main() { // fn main() {
// S { #[cfg(test)] field: 1 } // S { #[cfg(test)] field: 1 }
// } // }
attributes::outer_attributes(p); attributes::outer_attrs(p);
match p.current() { match p.current() {
IDENT | INT_NUMBER => { IDENT | INT_NUMBER => {

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

@ -75,9 +75,9 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar
T!['('] => tuple_expr(p), T!['('] => tuple_expr(p),
T!['['] => array_expr(p), T!['['] => array_expr(p),
L_DOLLAR => meta_var_expr(p), L_DOLLAR => meta_var_expr(p),
T![|] => lambda_expr(p), T![|] => closure_expr(p),
T![move] if la == T![|] => lambda_expr(p), T![move] if la == T![|] => closure_expr(p),
T![async] if la == T![|] || (la == T![move] && p.nth(2) == T![|]) => lambda_expr(p), T![async] if la == T![|] || (la == T![move] && p.nth(2) == T![|]) => closure_expr(p),
T![if] => if_expr(p), T![if] => if_expr(p),
T![loop] => loop_expr(p, None), T![loop] => loop_expr(p, None),
@ -228,7 +228,7 @@ fn array_expr(p: &mut Parser) -> CompletedMarker {
// move || {}; // move || {};
// async move || {}; // async move || {};
// } // }
fn lambda_expr(p: &mut Parser) -> CompletedMarker { fn closure_expr(p: &mut Parser) -> CompletedMarker {
assert!( assert!(
p.at(T![|]) p.at(T![|])
|| (p.at(T![move]) && p.nth(1) == T![|]) || (p.at(T![move]) && p.nth(1) == T![|])
@ -239,7 +239,7 @@ fn lambda_expr(p: &mut Parser) -> CompletedMarker {
p.eat(T![async]); p.eat(T![async]);
p.eat(T![move]); p.eat(T![move]);
params::param_list_closure(p); params::param_list_closure(p);
if opt_fn_ret_type(p) { if opt_ret_type(p) {
// test lambda_ret_block // test lambda_ret_block
// fn main() { || -> i32 { 92 }(); } // fn main() { || -> i32 { 92 }(); }
block_expr(p); block_expr(p);
@ -265,7 +265,7 @@ fn if_expr(p: &mut Parser) -> CompletedMarker {
assert!(p.at(T![if])); assert!(p.at(T![if]));
let m = p.start(); let m = p.start();
p.bump(T![if]); p.bump(T![if]);
cond(p); condition(p);
block_expr(p); block_expr(p);
if p.at(T![else]) { if p.at(T![else]) {
p.bump(T![else]); p.bump(T![else]);
@ -314,7 +314,7 @@ fn while_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
assert!(p.at(T![while])); assert!(p.at(T![while]));
let m = m.unwrap_or_else(|| p.start()); let m = m.unwrap_or_else(|| p.start());
p.bump(T![while]); p.bump(T![while]);
cond(p); condition(p);
block_expr(p); block_expr(p);
m.complete(p, WHILE_EXPR) m.complete(p, WHILE_EXPR)
} }
@ -342,7 +342,7 @@ fn for_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
// while let Some(_) | Some(_) = None {} // while let Some(_) | Some(_) = None {}
// while let | Some(_) = None {} // while let | Some(_) = None {}
// } // }
fn cond(p: &mut Parser) { fn condition(p: &mut Parser) {
let m = p.start(); let m = p.start();
if p.eat(T![let]) { if p.eat(T![let]) {
patterns::pattern_top(p); patterns::pattern_top(p);
@ -386,7 +386,7 @@ pub(crate) fn match_arm_list(p: &mut Parser) {
// _ => (), // _ => (),
// } // }
// } // }
attributes::inner_attributes(p); attributes::inner_attrs(p);
while !p.at(EOF) && !p.at(T!['}']) { while !p.at(EOF) && !p.at(T!['}']) {
if p.at(T!['{']) { if p.at(T!['{']) {
@ -437,7 +437,7 @@ fn match_arm(p: &mut Parser) -> BlockLike {
// _ => (), // _ => (),
// } // }
// } // }
attributes::outer_attributes(p); attributes::outer_attrs(p);
patterns::pattern_top_r(p, TokenSet::EMPTY); patterns::pattern_top_r(p, TokenSet::EMPTY);
if p.at(T![if]) { if p.at(T![if]) {

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

@ -6,9 +6,9 @@ mod traits;
mod use_item; mod use_item;
pub(crate) use self::{ pub(crate) use self::{
adt::{enum_variant_list, record_field_def_list}, adt::{record_field_list, variant_list},
expressions::{match_arm_list, record_field_list}, expressions::{match_arm_list, record_expr_field_list},
traits::{impl_item_list, trait_item_list}, traits::assoc_item_list,
use_item::use_tree_list, use_item::use_tree_list,
}; };
use super::*; use super::*;
@ -20,7 +20,7 @@ use super::*;
// super::baz! {} // super::baz! {}
// struct S; // 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_attributes(p); attributes::inner_attrs(p);
while !(stop_on_r_curly && p.at(T!['}']) || p.at(EOF)) { while !(stop_on_r_curly && p.at(T!['}']) || p.at(EOF)) {
item_or_macro(p, stop_on_r_curly) item_or_macro(p, stop_on_r_curly)
} }
@ -33,7 +33,7 @@ pub(super) const ITEM_RECOVERY_SET: TokenSet = token_set![
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(); let m = p.start();
attributes::outer_attributes(p); attributes::outer_attrs(p);
let m = match maybe_item(p, m) { let m = match maybe_item(p, m) {
Ok(()) => { Ok(()) => {
if p.at(T![;]) { if p.at(T![;]) {
@ -144,30 +144,30 @@ pub(super) fn maybe_item(p: &mut Parser, m: Marker) -> Result<(), Marker> {
// test fn // test fn
// fn foo() {} // fn foo() {}
T![fn] => { T![fn] => {
fn_def(p); fn_(p);
m.complete(p, FN); m.complete(p, FN);
} }
// test trait // test trait
// trait T {} // trait T {}
T![trait] => { T![trait] => {
traits::trait_def(p); traits::trait_(p);
m.complete(p, TRAIT); m.complete(p, TRAIT);
} }
T![const] => { T![const] => {
consts::const_def(p, m); consts::konst(p, m);
} }
// test impl // test impl
// impl T for S {} // impl T for S {}
T![impl] => { T![impl] => {
traits::impl_def(p); traits::impl_(p);
m.complete(p, IMPL); m.complete(p, IMPL);
} }
T![type] => { T![type] => {
type_def(p, m); type_alias(p, m);
} }
_ => { _ => {
if !has_visibility && !has_mods { if !has_visibility && !has_mods {
@ -190,9 +190,9 @@ fn items_without_modifiers(p: &mut Parser, m: Marker) -> Result<(), Marker> {
match p.current() { match p.current() {
// test extern_crate // test extern_crate
// extern crate foo; // extern crate foo;
T![extern] if la == T![crate] => extern_crate_item(p, m), T![extern] if la == T![crate] => extern_crate(p, m),
T![type] => { T![type] => {
type_def(p, m); type_alias(p, m);
} }
T![mod] => mod_item(p, m), T![mod] => mod_item(p, m),
T![struct] => { T![struct] => {
@ -205,7 +205,7 @@ fn items_without_modifiers(p: &mut Parser, m: Marker) -> Result<(), Marker> {
// a: i32, // a: i32,
// b: f32, // b: f32,
// } // }
adt::struct_def(p, m); adt::strukt(p, m);
} }
// test pub_macro_def // test pub_macro_def
// pub macro m($:ident) {} // pub macro m($:ident) {}
@ -219,12 +219,12 @@ fn items_without_modifiers(p: &mut Parser, m: Marker) -> Result<(), Marker> {
// a: i32, // a: i32,
// b: f32, // b: f32,
// } // }
adt::union_def(p, m); adt::union(p, m);
} }
T![enum] => adt::enum_def(p, m), T![enum] => adt::enum_(p, m),
T![use] => use_item::use_item(p, m), T![use] => use_item::use_(p, m),
T![const] if (la == IDENT || la == T![_] || la == T![mut]) => consts::const_def(p, m), T![const] if (la == IDENT || la == T![_] || la == T![mut]) => consts::konst(p, m),
T![static] => consts::static_def(p, m), T![static] => consts::static_(p, m),
// test extern_block // test extern_block
// extern {} // extern {}
T![extern] T![extern]
@ -239,7 +239,7 @@ fn items_without_modifiers(p: &mut Parser, m: Marker) -> Result<(), Marker> {
Ok(()) Ok(())
} }
fn extern_crate_item(p: &mut Parser, m: Marker) { fn extern_crate(p: &mut Parser, m: Marker) {
assert!(p.at(T![extern])); assert!(p.at(T![extern]));
p.bump(T![extern]); p.bump(T![extern]);
assert!(p.at(T![crate])); assert!(p.at(T![crate]));
@ -251,7 +251,7 @@ fn extern_crate_item(p: &mut Parser, m: Marker) {
name_ref(p); name_ref(p);
} }
opt_alias(p); opt_rename(p);
p.expect(T![;]); p.expect(T![;]);
m.complete(p, EXTERN_CRATE); m.complete(p, EXTERN_CRATE);
} }
@ -265,14 +265,14 @@ pub(crate) fn extern_item_list(p: &mut Parser) {
m.complete(p, EXTERN_ITEM_LIST); m.complete(p, EXTERN_ITEM_LIST);
} }
fn fn_def(p: &mut Parser) { fn fn_(p: &mut Parser) {
assert!(p.at(T![fn])); assert!(p.at(T![fn]));
p.bump(T![fn]); p.bump(T![fn]);
name_r(p, ITEM_RECOVERY_SET); name_r(p, ITEM_RECOVERY_SET);
// test function_type_params // test function_type_params
// fn foo<T: Clone + Copy>(){} // fn foo<T: Clone + Copy>(){}
type_params::opt_type_param_list(p); type_params::opt_generic_param_list(p);
if p.at(T!['(']) { if p.at(T!['(']) {
params::param_list_fn_def(p); params::param_list_fn_def(p);
@ -282,7 +282,7 @@ fn fn_def(p: &mut Parser) {
// test function_ret_type // test function_ret_type
// fn foo() {} // fn foo() {}
// fn bar() -> () {} // fn bar() -> () {}
opt_fn_ret_type(p); opt_ret_type(p);
// test function_where_clause // test function_where_clause
// fn foo<T>() where T: Copy {} // fn foo<T>() where T: Copy {}
@ -299,7 +299,7 @@ fn fn_def(p: &mut Parser) {
// test type_item // test type_item
// type Foo = Bar; // type Foo = Bar;
fn type_def(p: &mut Parser, m: Marker) { fn type_alias(p: &mut Parser, m: Marker) {
assert!(p.at(T![type])); assert!(p.at(T![type]));
p.bump(T![type]); p.bump(T![type]);
@ -307,7 +307,7 @@ fn type_def(p: &mut Parser, m: Marker) {
// test type_item_type_params // test type_item_type_params
// type Result<T> = (); // type Result<T> = ();
type_params::opt_type_param_list(p); type_params::opt_generic_param_list(p);
if p.at(T![:]) { if p.at(T![:]) {
type_params::bounds(p); type_params::bounds(p);
@ -329,14 +329,14 @@ pub(crate) fn mod_item(p: &mut Parser, m: Marker) {
name(p); name(p);
if p.at(T!['{']) { if p.at(T!['{']) {
mod_item_list(p); item_list(p);
} else if !p.eat(T![;]) { } else if !p.eat(T![;]) {
p.error("expected `;` or `{`"); p.error("expected `;` or `{`");
} }
m.complete(p, MODULE); m.complete(p, MODULE);
} }
pub(crate) fn mod_item_list(p: &mut Parser) { pub(crate) fn item_list(p: &mut Parser) {
assert!(p.at(T!['{'])); assert!(p.at(T!['{']));
let m = p.start(); let m = p.start();
p.bump(T!['{']); p.bump(T!['{']);

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

@ -2,13 +2,13 @@
use super::*; use super::*;
pub(super) fn struct_def(p: &mut Parser, m: Marker) { pub(super) fn strukt(p: &mut Parser, m: Marker) {
assert!(p.at(T![struct])); assert!(p.at(T![struct]));
p.bump(T![struct]); p.bump(T![struct]);
struct_or_union(p, m, T![struct], STRUCT); struct_or_union(p, m, T![struct], STRUCT);
} }
pub(super) fn union_def(p: &mut Parser, m: Marker) { pub(super) fn union(p: &mut Parser, m: Marker) {
assert!(p.at_contextual_kw("union")); assert!(p.at_contextual_kw("union"));
p.bump_remap(T![union]); p.bump_remap(T![union]);
struct_or_union(p, m, T![union], UNION); struct_or_union(p, m, T![union], UNION);
@ -16,7 +16,7 @@ pub(super) fn union_def(p: &mut Parser, m: Marker) {
fn struct_or_union(p: &mut Parser, m: Marker, kw: SyntaxKind, def: SyntaxKind) { fn struct_or_union(p: &mut Parser, m: Marker, kw: SyntaxKind, def: SyntaxKind) {
name_r(p, ITEM_RECOVERY_SET); name_r(p, ITEM_RECOVERY_SET);
type_params::opt_type_param_list(p); type_params::opt_generic_param_list(p);
match p.current() { match p.current() {
T![where] => { T![where] => {
type_params::opt_where_clause(p); type_params::opt_where_clause(p);
@ -24,7 +24,7 @@ fn struct_or_union(p: &mut Parser, m: Marker, kw: SyntaxKind, def: SyntaxKind) {
T![;] => { T![;] => {
p.bump(T![;]); p.bump(T![;]);
} }
T!['{'] => record_field_def_list(p), T!['{'] => record_field_list(p),
_ => { _ => {
//FIXME: special case `(` error message //FIXME: special case `(` error message
p.error("expected `;` or `{`"); p.error("expected `;` or `{`");
@ -34,9 +34,9 @@ fn struct_or_union(p: &mut Parser, m: Marker, kw: SyntaxKind, def: SyntaxKind) {
T![;] if kw == T![struct] => { T![;] if kw == T![struct] => {
p.bump(T![;]); p.bump(T![;]);
} }
T!['{'] => record_field_def_list(p), T!['{'] => record_field_list(p),
T!['('] if kw == T![struct] => { T!['('] if kw == T![struct] => {
tuple_field_def_list(p); tuple_field_list(p);
// test tuple_struct_where // test tuple_struct_where
// struct Test<T>(T) where T: Clone; // struct Test<T>(T) where T: Clone;
// struct Test<T>(T); // struct Test<T>(T);
@ -53,21 +53,21 @@ fn struct_or_union(p: &mut Parser, m: Marker, kw: SyntaxKind, def: SyntaxKind) {
m.complete(p, def); m.complete(p, def);
} }
pub(super) fn enum_def(p: &mut Parser, m: Marker) { pub(super) fn enum_(p: &mut Parser, m: Marker) {
assert!(p.at(T![enum])); assert!(p.at(T![enum]));
p.bump(T![enum]); p.bump(T![enum]);
name_r(p, ITEM_RECOVERY_SET); name_r(p, ITEM_RECOVERY_SET);
type_params::opt_type_param_list(p); type_params::opt_generic_param_list(p);
type_params::opt_where_clause(p); type_params::opt_where_clause(p);
if p.at(T!['{']) { if p.at(T!['{']) {
enum_variant_list(p); variant_list(p);
} else { } else {
p.error("expected `{`") p.error("expected `{`")
} }
m.complete(p, ENUM); m.complete(p, ENUM);
} }
pub(crate) fn enum_variant_list(p: &mut Parser) { pub(crate) fn variant_list(p: &mut Parser) {
assert!(p.at(T!['{'])); assert!(p.at(T!['{']));
let m = p.start(); let m = p.start();
p.bump(T!['{']); p.bump(T!['{']);
@ -77,12 +77,12 @@ pub(crate) fn enum_variant_list(p: &mut Parser) {
continue; continue;
} }
let var = p.start(); let var = p.start();
attributes::outer_attributes(p); attributes::outer_attrs(p);
if p.at(IDENT) { if p.at(IDENT) {
name(p); name(p);
match p.current() { match p.current() {
T!['{'] => record_field_def_list(p), T!['{'] => record_field_list(p),
T!['('] => tuple_field_def_list(p), T!['('] => tuple_field_list(p),
_ => (), _ => (),
} }
@ -104,7 +104,7 @@ pub(crate) fn enum_variant_list(p: &mut Parser) {
m.complete(p, VARIANT_LIST); m.complete(p, VARIANT_LIST);
} }
pub(crate) fn record_field_def_list(p: &mut Parser) { pub(crate) fn record_field_list(p: &mut Parser) {
assert!(p.at(T!['{'])); assert!(p.at(T!['{']));
let m = p.start(); let m = p.start();
p.bump(T!['{']); p.bump(T!['{']);
@ -128,7 +128,7 @@ pub(crate) fn record_field_def_list(p: &mut Parser) {
// #[serde(with = "url_serde")] // #[serde(with = "url_serde")]
// pub uri: Uri, // pub uri: Uri,
// } // }
attributes::outer_attributes(p); attributes::outer_attrs(p);
opt_visibility(p); opt_visibility(p);
if p.at(IDENT) { if p.at(IDENT) {
name(p); name(p);
@ -142,7 +142,7 @@ pub(crate) fn record_field_def_list(p: &mut Parser) {
} }
} }
fn tuple_field_def_list(p: &mut Parser) { fn tuple_field_list(p: &mut Parser) {
assert!(p.at(T!['('])); assert!(p.at(T!['(']));
let m = p.start(); let m = p.start();
if !p.expect(T!['(']) { if !p.expect(T!['(']) {
@ -159,7 +159,7 @@ fn tuple_field_def_list(p: &mut Parser) {
// enum S { // enum S {
// Uri(#[serde(with = "url_serde")] Uri), // Uri(#[serde(with = "url_serde")] Uri),
// } // }
attributes::outer_attributes(p); attributes::outer_attrs(p);
opt_visibility(p); opt_visibility(p);
if !p.at_ts(types::TYPE_FIRST) { if !p.at_ts(types::TYPE_FIRST) {
p.error("expected a type"); p.error("expected a type");

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

@ -2,11 +2,11 @@
use super::*; use super::*;
pub(super) fn static_def(p: &mut Parser, m: Marker) { pub(super) fn static_(p: &mut Parser, m: Marker) {
const_or_static(p, m, T![static], STATIC) const_or_static(p, m, T![static], STATIC)
} }
pub(super) fn const_def(p: &mut Parser, m: Marker) { pub(super) fn konst(p: &mut Parser, m: Marker) {
const_or_static(p, m, T![const], CONST) const_or_static(p, m, T![const], CONST)
} }

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

@ -5,11 +5,11 @@ use super::*;
// test trait_item // test trait_item
// trait T<U>: Hash + Clone where U: Copy {} // trait T<U>: Hash + Clone where U: Copy {}
// trait X<U: Debug + Display>: Hash + Clone where U: Copy {} // trait X<U: Debug + Display>: Hash + Clone where U: Copy {}
pub(super) fn trait_def(p: &mut Parser) { pub(super) fn trait_(p: &mut Parser) {
assert!(p.at(T![trait])); assert!(p.at(T![trait]));
p.bump(T![trait]); p.bump(T![trait]);
name_r(p, ITEM_RECOVERY_SET); name_r(p, ITEM_RECOVERY_SET);
type_params::opt_type_param_list(p); type_params::opt_generic_param_list(p);
// test trait_alias // test trait_alias
// trait Z<U> = T<U>; // trait Z<U> = T<U>;
// trait Z<U> = T<U> where U: Copy; // trait Z<U> = T<U> where U: Copy;
@ -25,41 +25,19 @@ pub(super) fn trait_def(p: &mut Parser) {
} }
type_params::opt_where_clause(p); type_params::opt_where_clause(p);
if p.at(T!['{']) { if p.at(T!['{']) {
trait_item_list(p); assoc_item_list(p);
} else { } else {
p.error("expected `{`"); p.error("expected `{`");
} }
} }
// test trait_item_list
// impl F {
// type A: Clone;
// const B: i32;
// fn foo() {}
// fn bar(&self);
// }
pub(crate) fn trait_item_list(p: &mut Parser) {
assert!(p.at(T!['{']));
let m = p.start();
p.bump(T!['{']);
while !p.at(EOF) && !p.at(T!['}']) {
if p.at(T!['{']) {
error_block(p, "expected an item");
continue;
}
item_or_macro(p, true);
}
p.expect(T!['}']);
m.complete(p, ASSOC_ITEM_LIST);
}
// test impl_def // test impl_def
// impl Foo {} // impl Foo {}
pub(super) fn impl_def(p: &mut Parser) { pub(super) fn impl_(p: &mut Parser) {
assert!(p.at(T![impl])); assert!(p.at(T![impl]));
p.bump(T![impl]); p.bump(T![impl]);
if choose_type_params_over_qpath(p) { if choose_type_params_over_qpath(p) {
type_params::opt_type_param_list(p); type_params::opt_generic_param_list(p);
} }
// FIXME: never type // FIXME: never type
@ -74,7 +52,7 @@ pub(super) fn impl_def(p: &mut Parser) {
} }
type_params::opt_where_clause(p); type_params::opt_where_clause(p);
if p.at(T!['{']) { if p.at(T!['{']) {
impl_item_list(p); assoc_item_list(p);
} else { } else {
p.error("expected `{`"); p.error("expected `{`");
} }
@ -87,7 +65,7 @@ pub(super) fn impl_def(p: &mut Parser) {
// fn foo() {} // fn foo() {}
// fn bar(&self) {} // fn bar(&self) {}
// } // }
pub(crate) fn impl_item_list(p: &mut Parser) { pub(crate) fn assoc_item_list(p: &mut Parser) {
assert!(p.at(T!['{'])); assert!(p.at(T!['{']));
let m = p.start(); let m = p.start();
p.bump(T!['{']); p.bump(T!['{']);
@ -97,7 +75,7 @@ pub(crate) fn impl_item_list(p: &mut Parser) {
// //! This is a doc comment // //! This is a doc comment
// #![doc("This is also a doc comment")] // #![doc("This is also a doc comment")]
// } // }
attributes::inner_attributes(p); attributes::inner_attrs(p);
while !p.at(EOF) && !p.at(T!['}']) { while !p.at(EOF) && !p.at(T!['}']) {
if p.at(T!['{']) { if p.at(T!['{']) {

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

@ -2,7 +2,7 @@
use super::*; use super::*;
pub(super) fn use_item(p: &mut Parser, m: Marker) { pub(super) fn use_(p: &mut Parser, m: Marker) {
assert!(p.at(T![use])); assert!(p.at(T![use]));
p.bump(T![use]); p.bump(T![use]);
use_tree(p, true); use_tree(p, true);
@ -80,7 +80,7 @@ fn use_tree(p: &mut Parser, top_level: bool) {
// running::out::of::synonyms::for_::different::* // running::out::of::synonyms::for_::different::*
// }; // };
// use Trait as _; // use Trait as _;
opt_alias(p); opt_rename(p);
} }
T![:] if p.at(T![::]) => { T![:] if p.at(T![::]) => {
p.bump(T![::]); p.bump(T![::]);

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

@ -47,20 +47,20 @@ fn list_(p: &mut Parser, flavor: Flavor) {
if let FnDef = flavor { if let FnDef = flavor {
// test self_param_outer_attr // test self_param_outer_attr
// fn f(#[must_use] self) {} // fn f(#[must_use] self) {}
attributes::outer_attributes(p); attributes::outer_attrs(p);
opt_self_param(p); opt_self_param(p);
} }
while !p.at(EOF) && !p.at(ket) { while !p.at(EOF) && !p.at(ket) {
// test param_outer_arg // test param_outer_arg
// fn f(#[attr1] pat: Type) {} // fn f(#[attr1] pat: Type) {}
attributes::outer_attributes(p); attributes::outer_attrs(p);
if !p.at_ts(VALUE_PARAMETER_FIRST) { if !p.at_ts(PARAM_FIRST) {
p.error("expected value parameter"); p.error("expected value parameter");
break; break;
} }
let param = value_parameter(p, flavor); let param = param(p, flavor);
if !p.at(ket) { if !p.at(ket) {
p.expect(T![,]); p.expect(T![,]);
} }
@ -73,11 +73,11 @@ fn list_(p: &mut Parser, flavor: Flavor) {
m.complete(p, PARAM_LIST); m.complete(p, PARAM_LIST);
} }
const VALUE_PARAMETER_FIRST: TokenSet = patterns::PATTERN_FIRST.union(types::TYPE_FIRST); const PARAM_FIRST: TokenSet = patterns::PATTERN_FIRST.union(types::TYPE_FIRST);
struct Variadic(bool); struct Variadic(bool);
fn value_parameter(p: &mut Parser, flavor: Flavor) -> Variadic { fn param(p: &mut Parser, flavor: Flavor) -> Variadic {
let mut res = Variadic(false); let mut res = Variadic(false);
let m = p.start(); let m = p.start();
match flavor { match flavor {

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

@ -105,11 +105,11 @@ fn opt_path_type_args(p: &mut Parser, mode: Mode) {
// type F = Box<Fn(i32) -> ()>; // type F = Box<Fn(i32) -> ()>;
if p.at(T!['(']) { if p.at(T!['(']) {
params::param_list_fn_trait(p); params::param_list_fn_trait(p);
opt_fn_ret_type(p); opt_ret_type(p);
} else { } else {
type_args::opt_type_arg_list(p, false) type_args::opt_generic_arg_list(p, false)
} }
} }
Mode::Expr => type_args::opt_type_arg_list(p, true), Mode::Expr => type_args::opt_generic_arg_list(p, true),
} }
} }

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

@ -79,13 +79,13 @@ const PAT_RECOVERY_SET: TokenSet =
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.nth(0) { let m = match p.nth(0) {
T![box] => box_pat(p), T![box] => box_pat(p),
T![ref] | T![mut] => bind_pat(p, true), T![ref] | T![mut] => ident_pat(p, true),
IDENT => match p.nth(1) { IDENT => match p.nth(1) {
// Checks the token after an IDENT to see if a pattern is a path (Struct { .. }) or macro // Checks the token after an IDENT to see if a pattern is a path (Struct { .. }) or macro
// (T![x]). // (T![x]).
T!['('] | T!['{'] | T![!] => path_or_macro_pat(p), T!['('] | T!['{'] | T![!] => path_or_macro_pat(p),
T![:] if p.nth_at(1, T![::]) => path_or_macro_pat(p), T![:] if p.nth_at(1, T![::]) => path_or_macro_pat(p),
_ => bind_pat(p, true), _ => ident_pat(p, true),
}, },
// test type_path_in_pattern // test type_path_in_pattern
@ -93,8 +93,8 @@ fn atom_pat(p: &mut Parser, recovery_set: TokenSet) -> Option<CompletedMarker> {
_ if paths::is_path_start(p) => path_or_macro_pat(p), _ if paths::is_path_start(p) => path_or_macro_pat(p),
_ if is_literal_pat_start(p) => literal_pat(p), _ if is_literal_pat_start(p) => literal_pat(p),
T![.] if p.at(T![..]) => dot_dot_pat(p), T![.] if p.at(T![..]) => rest_pat(p),
T![_] => placeholder_pat(p), T![_] => wildcard_pat(p),
T![&] => ref_pat(p), T![&] => ref_pat(p),
T!['('] => tuple_pat(p), T!['('] => tuple_pat(p),
T!['['] => slice_pat(p), T!['['] => slice_pat(p),
@ -149,7 +149,7 @@ fn path_or_macro_pat(p: &mut Parser) -> CompletedMarker {
TUPLE_STRUCT_PAT TUPLE_STRUCT_PAT
} }
T!['{'] => { T!['{'] => {
record_field_pat_list(p); record_pat_field_list(p);
RECORD_PAT RECORD_PAT
} }
// test marco_pat // test marco_pat
@ -186,7 +186,7 @@ fn tuple_pat_fields(p: &mut Parser) {
// let S { h: _, ..} = (); // let S { h: _, ..} = ();
// let S { h: _, } = (); // let S { h: _, } = ();
// } // }
fn record_field_pat_list(p: &mut Parser) { fn record_pat_field_list(p: &mut Parser) {
assert!(p.at(T!['{'])); assert!(p.at(T!['{']));
let m = p.start(); let m = p.start();
p.bump(T!['{']); p.bump(T!['{']);
@ -214,7 +214,7 @@ fn record_field_pat_list(p: &mut Parser) {
box_pat(p); box_pat(p);
} }
_ => { _ => {
bind_pat(p, false); ident_pat(p, false);
} }
} }
m.complete(p, RECORD_PAT_FIELD); m.complete(p, RECORD_PAT_FIELD);
@ -230,7 +230,7 @@ fn record_field_pat_list(p: &mut Parser) {
// test placeholder_pat // test placeholder_pat
// fn main() { let _ = (); } // fn main() { let _ = (); }
fn placeholder_pat(p: &mut Parser) -> CompletedMarker { fn wildcard_pat(p: &mut Parser) -> CompletedMarker {
assert!(p.at(T![_])); assert!(p.at(T![_]));
let m = p.start(); let m = p.start();
p.bump(T![_]); p.bump(T![_]);
@ -263,7 +263,7 @@ fn placeholder_pat(p: &mut Parser) -> CompletedMarker {
// let [head, .., mid, tail @ ..] = (); // let [head, .., mid, tail @ ..] = ();
// let [head, .., mid, .., cons] = (); // let [head, .., mid, .., cons] = ();
// } // }
fn dot_dot_pat(p: &mut Parser) -> CompletedMarker { fn rest_pat(p: &mut Parser) -> CompletedMarker {
assert!(p.at(T![..])); assert!(p.at(T![..]));
let m = p.start(); let m = p.start();
p.bump(T![..]); p.bump(T![..]);
@ -353,7 +353,7 @@ fn pat_list(p: &mut Parser, ket: SyntaxKind) {
// let e @ _ = (); // let e @ _ = ();
// let ref mut f @ g @ _ = (); // let ref mut f @ g @ _ = ();
// } // }
fn bind_pat(p: &mut Parser, with_at: bool) -> CompletedMarker { fn ident_pat(p: &mut Parser, with_at: bool) -> CompletedMarker {
let m = p.start(); let m = p.start();
p.eat(T![ref]); p.eat(T![ref]);
p.eat(T![mut]); p.eat(T![mut]);

6
crates/parser/src/grammar/type_args.rs
View file

@ -2,7 +2,7 @@
use super::*; use super::*;
pub(super) fn opt_type_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; let m;
if p.at(T![::]) && p.nth(2) == T![<] { if p.at(T![::]) && p.nth(2) == T![<] {
m = p.start(); m = p.start();
@ -16,7 +16,7 @@ pub(super) fn opt_type_arg_list(p: &mut Parser, colon_colon_required: bool) {
} }
while !p.at(EOF) && !p.at(T![>]) { while !p.at(EOF) && !p.at(T![>]) {
type_arg(p); generic_arg(p);
if !p.at(T![>]) && !p.expect(T![,]) { if !p.at(T![>]) && !p.expect(T![,]) {
break; break;
} }
@ -27,7 +27,7 @@ pub(super) fn opt_type_arg_list(p: &mut Parser, colon_colon_required: bool) {
// test type_arg // test type_arg
// type A = B<'static, i32, 1, { 2 }, Item=u64>; // type A = B<'static, i32, 1, { 2 }, Item=u64>;
fn type_arg(p: &mut Parser) { fn generic_arg(p: &mut Parser) {
let m = p.start(); let m = p.start();
match p.current() { match p.current() {
LIFETIME => { LIFETIME => {

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

@ -2,14 +2,14 @@
use super::*; use super::*;
pub(super) fn opt_type_param_list(p: &mut Parser) { pub(super) fn opt_generic_param_list(p: &mut Parser) {
if !p.at(T![<]) { if !p.at(T![<]) {
return; return;
} }
type_param_list(p); generic_param_list(p);
} }
fn type_param_list(p: &mut Parser) { fn generic_param_list(p: &mut Parser) {
assert!(p.at(T![<])); assert!(p.at(T![<]));
let m = p.start(); let m = p.start();
p.bump(T![<]); p.bump(T![<]);
@ -20,12 +20,12 @@ fn type_param_list(p: &mut Parser) {
// test generic_lifetime_type_attribute // test generic_lifetime_type_attribute
// fn foo<#[derive(Lifetime)] 'a, #[derive(Type)] T>(_: &'a T) { // fn foo<#[derive(Lifetime)] 'a, #[derive(Type)] T>(_: &'a T) {
// } // }
attributes::outer_attributes(p); attributes::outer_attrs(p);
match p.current() { match p.current() {
LIFETIME => lifetime_param(p, m), LIFETIME => lifetime_param(p, m),
IDENT => type_param(p, m), IDENT => type_param(p, m),
CONST_KW => type_const_param(p, m), CONST_KW => const_param(p, m),
_ => { _ => {
m.abandon(p); m.abandon(p);
p.err_and_bump("expected type parameter") p.err_and_bump("expected type parameter")
@ -65,7 +65,7 @@ fn type_param(p: &mut Parser, m: Marker) {
// test const_param // test const_param
// struct S<const N: u32>; // struct S<const N: u32>;
fn type_const_param(p: &mut Parser, m: Marker) { fn const_param(p: &mut Parser, m: Marker) {
assert!(p.at(CONST_KW)); assert!(p.at(CONST_KW));
p.bump(T![const]); p.bump(T![const]);
name(p); name(p);

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

@ -32,11 +32,11 @@ fn type_with_bounds_cond(p: &mut Parser, allow_bounds: bool) {
match p.current() { match p.current() {
T!['('] => paren_or_tuple_type(p), T!['('] => paren_or_tuple_type(p),
T![!] => never_type(p), T![!] => never_type(p),
T![*] => pointer_type(p), T![*] => ptr_type(p),
T!['['] => array_or_slice_type(p), T!['['] => array_or_slice_type(p),
T![&] => reference_type(p), T![&] => ref_type(p),
T![_] => placeholder_type(p), T![_] => infer_type(p),
T![fn] | T![unsafe] | T![extern] => fn_pointer_type(p), T![fn] | T![unsafe] | T![extern] => fn_ptr_type(p),
T![for] => for_type(p), T![for] => for_type(p),
T![impl] => impl_trait_type(p), T![impl] => impl_trait_type(p),
T![dyn] => dyn_trait_type(p), T![dyn] => dyn_trait_type(p),
@ -96,7 +96,7 @@ fn never_type(p: &mut Parser) {
m.complete(p, NEVER_TYPE); m.complete(p, NEVER_TYPE);
} }
fn pointer_type(p: &mut Parser) { fn ptr_type(p: &mut Parser) {
assert!(p.at(T![*])); assert!(p.at(T![*]));
let m = p.start(); let m = p.start();
p.bump(T![*]); p.bump(T![*]);
@ -156,7 +156,7 @@ fn array_or_slice_type(p: &mut Parser) {
// type A = &(); // type A = &();
// type B = &'static (); // type B = &'static ();
// type C = &mut (); // type C = &mut ();
fn reference_type(p: &mut Parser) { fn ref_type(p: &mut Parser) {
assert!(p.at(T![&])); assert!(p.at(T![&]));
let m = p.start(); let m = p.start();
p.bump(T![&]); p.bump(T![&]);
@ -168,7 +168,7 @@ fn reference_type(p: &mut Parser) {
// test placeholder_type // test placeholder_type
// type Placeholder = _; // type Placeholder = _;
fn placeholder_type(p: &mut Parser) { fn infer_type(p: &mut Parser) {
assert!(p.at(T![_])); assert!(p.at(T![_]));
let m = p.start(); let m = p.start();
p.bump(T![_]); p.bump(T![_]);
@ -180,7 +180,7 @@ fn placeholder_type(p: &mut Parser) {
// type B = unsafe fn(); // type B = unsafe fn();
// type C = unsafe extern "C" fn(); // type C = unsafe extern "C" fn();
// type D = extern "C" fn ( u8 , ... ) -> u8; // type D = extern "C" fn ( u8 , ... ) -> u8;
fn fn_pointer_type(p: &mut Parser) { fn fn_ptr_type(p: &mut Parser) {
let m = p.start(); let m = p.start();
p.eat(T![unsafe]); p.eat(T![unsafe]);
if p.at(T![extern]) { if p.at(T![extern]) {
@ -200,7 +200,7 @@ fn fn_pointer_type(p: &mut Parser) {
} }
// test fn_pointer_type_with_ret // test fn_pointer_type_with_ret
// type F = fn() -> (); // type F = fn() -> ();
opt_fn_ret_type(p); opt_ret_type(p);
m.complete(p, FN_PTR_TYPE); m.complete(p, FN_PTR_TYPE);
} }
@ -208,7 +208,7 @@ pub(super) fn for_binder(p: &mut Parser) {
assert!(p.at(T![for])); assert!(p.at(T![for]));
p.bump(T![for]); p.bump(T![for]);
if p.at(T![<]) { if p.at(T![<]) {
type_params::opt_type_param_list(p); type_params::opt_generic_param_list(p);
} else { } else {
p.error("expected `<`"); p.error("expected `<`");
} }

71
crates/syntax/test_data/parser/inline/ok/0001_trait_item_list.rast
View file

@ -1,71 +0,0 @@
SOURCE_FILE@0..83
IMPL@0..82
IMPL_KW@0..4 "impl"
WHITESPACE@4..5 " "
PATH_TYPE@5..6
PATH@5..6
PATH_SEGMENT@5..6
NAME_REF@5..6
IDENT@5..6 "F"
WHITESPACE@6..7 " "
ASSOC_ITEM_LIST@7..82
L_CURLY@7..8 "{"
WHITESPACE@8..13 "\n "
TYPE_ALIAS@13..27
TYPE_KW@13..17 "type"
WHITESPACE@17..18 " "
NAME@18..19
IDENT@18..19 "A"
COLON@19..20 ":"
WHITESPACE@20..21 " "
TYPE_BOUND_LIST@21..26
TYPE_BOUND@21..26
PATH_TYPE@21..26
PATH@21..26
PATH_SEGMENT@21..26
NAME_REF@21..26
IDENT@21..26 "Clone"
SEMICOLON@26..27 ";"
WHITESPACE@27..32 "\n "
CONST@32..45
CONST_KW@32..37 "const"
WHITESPACE@37..38 " "
NAME@38..39
IDENT@38..39 "B"
COLON@39..40 ":"
WHITESPACE@40..41 " "
PATH_TYPE@41..44
PATH@41..44
PATH_SEGMENT@41..44
NAME_REF@41..44
IDENT@41..44 "i32"
SEMICOLON@44..45 ";"
WHITESPACE@45..50 "\n "
FN@50..61
FN_KW@50..52 "fn"
WHITESPACE@52..53 " "
NAME@53..56
IDENT@53..56 "foo"
PARAM_LIST@56..58
L_PAREN@56..57 "("
R_PAREN@57..58 ")"
WHITESPACE@58..59 " "
BLOCK_EXPR@59..61
L_CURLY@59..60 "{"
R_CURLY@60..61 "}"
WHITESPACE@61..66 "\n "
FN@66..80
FN_KW@66..68 "fn"
WHITESPACE@68..69 " "
NAME@69..72
IDENT@69..72 "bar"
PARAM_LIST@72..79
L_PAREN@72..73 "("
SELF_PARAM@73..78
AMP@73..74 "&"
SELF_KW@74..78 "self"
R_PAREN@78..79 ")"
SEMICOLON@79..80 ";"
WHITESPACE@80..81 "\n"
R_CURLY@81..82 "}"
WHITESPACE@82..83 "\n"

6
crates/syntax/test_data/parser/inline/ok/0001_trait_item_list.rs
View file

@ -1,6 +0,0 @@
impl F {
type A: Clone;
const B: i32;
fn foo() {}
fn bar(&self);
}