aboutsummaryrefslogtreecommitdiff
path: root/crates/parser
diff options
context:
space:
mode:
Diffstat (limited to 'crates/parser')
-rw-r--r--crates/parser/src/grammar.rs16
-rw-r--r--crates/parser/src/grammar/attributes.rs10
-rw-r--r--crates/parser/src/grammar/expressions.rs14
-rw-r--r--crates/parser/src/grammar/expressions/atom.rs20
-rw-r--r--crates/parser/src/grammar/items.rs54
-rw-r--r--crates/parser/src/grammar/items/adt.rs34
-rw-r--r--crates/parser/src/grammar/items/consts.rs4
-rw-r--r--crates/parser/src/grammar/items/traits.rs38
-rw-r--r--crates/parser/src/grammar/items/use_item.rs4
-rw-r--r--crates/parser/src/grammar/params.rs12
-rw-r--r--crates/parser/src/grammar/paths.rs6
-rw-r--r--crates/parser/src/grammar/patterns.rs20
-rw-r--r--crates/parser/src/grammar/type_args.rs6
-rw-r--r--crates/parser/src/grammar/type_params.rs12
-rw-r--r--crates/parser/src/grammar/types.rs20
15 files changed, 124 insertions, 146 deletions
diff --git a/crates/parser/src/grammar.rs b/crates/parser/src/grammar.rs
index 9dbd2ebc4..562e92252 100644
--- a/crates/parser/src/grammar.rs
+++ b/crates/parser/src/grammar.rs
@@ -142,19 +142,19 @@ pub(crate) fn reparser(
142) -> Option<fn(&mut Parser)> { 142) -> Option<fn(&mut Parser)> {
143 let res = match node { 143 let res = match node {
144 BLOCK_EXPR => expressions::block_expr, 144 BLOCK_EXPR => expressions::block_expr,
145 RECORD_FIELD_LIST => items::record_field_def_list, 145 RECORD_FIELD_LIST => items::record_field_list,
146 RECORD_EXPR_FIELD_LIST => items::record_field_list, 146 RECORD_EXPR_FIELD_LIST => items::record_expr_field_list,
147 VARIANT_LIST => items::enum_variant_list, 147 VARIANT_LIST => items::variant_list,
148 MATCH_ARM_LIST => items::match_arm_list, 148 MATCH_ARM_LIST => items::match_arm_list,
149 USE_TREE_LIST => items::use_tree_list, 149 USE_TREE_LIST => items::use_tree_list,
150 EXTERN_ITEM_LIST => items::extern_item_list, 150 EXTERN_ITEM_LIST => items::extern_item_list,
151 TOKEN_TREE if first_child? == T!['{'] => items::token_tree, 151 TOKEN_TREE if first_child? == T!['{'] => items::token_tree,
152 ASSOC_ITEM_LIST => match parent? { 152 ASSOC_ITEM_LIST => match parent? {
153 IMPL => items::impl_item_list, 153 IMPL => items::assoc_item_list,
154 TRAIT => items::trait_item_list, 154 TRAIT => items::assoc_item_list,
155 _ => return None, 155 _ => return None,
156 }, 156 },
157 ITEM_LIST => items::mod_item_list, 157 ITEM_LIST => items::item_list,
158 _ => return None, 158 _ => return None,
159 }; 159 };
160 Some(res) 160 Some(res)
@@ -217,7 +217,7 @@ fn opt_visibility(p: &mut Parser) -> bool {
217 true 217 true
218} 218}
219 219
220fn opt_alias(p: &mut Parser) { 220fn opt_rename(p: &mut Parser) {
221 if p.at(T![as]) { 221 if p.at(T![as]) {
222 let m = p.start(); 222 let m = p.start();
223 p.bump(T![as]); 223 p.bump(T![as]);
@@ -239,7 +239,7 @@ fn abi(p: &mut Parser) {
239 abi.complete(p, ABI); 239 abi.complete(p, ABI);
240} 240}
241 241
242fn opt_fn_ret_type(p: &mut Parser) -> bool { 242fn opt_ret_type(p: &mut Parser) -> bool {
243 if p.at(T![->]) { 243 if p.at(T![->]) {
244 let m = p.start(); 244 let m = p.start();
245 p.bump(T![->]); 245 p.bump(T![->]);
diff --git a/crates/parser/src/grammar/attributes.rs b/crates/parser/src/grammar/attributes.rs
index f3158ade3..dab0f62c3 100644
--- a/crates/parser/src/grammar/attributes.rs
+++ b/crates/parser/src/grammar/attributes.rs
@@ -2,19 +2,19 @@
2 2
3use super::*; 3use super::*;
4 4
5pub(super) fn inner_attributes(p: &mut Parser) { 5pub(super) fn inner_attrs(p: &mut Parser) {
6 while p.at(T![#]) && p.nth(1) == T![!] { 6 while p.at(T![#]) && p.nth(1) == T![!] {
7 attribute(p, true) 7 attr(p, true)
8 } 8 }
9} 9}
10 10
11pub(super) fn outer_attributes(p: &mut Parser) { 11pub(super) fn outer_attrs(p: &mut Parser) {
12 while p.at(T![#]) { 12 while p.at(T![#]) {
13 attribute(p, false) 13 attr(p, false)
14 } 14 }
15} 15}
16 16
17fn attribute(p: &mut Parser, inner: bool) { 17fn attr(p: &mut Parser, inner: bool) {
18 let attr = p.start(); 18 let attr = p.start();
19 assert!(p.at(T![#])); 19 assert!(p.at(T![#]));
20 p.bump(T![#]); 20 p.bump(T![#]);
diff --git a/crates/parser/src/grammar/expressions.rs b/crates/parser/src/grammar/expressions.rs
index 3291e3f14..e72929f8c 100644
--- a/crates/parser/src/grammar/expressions.rs
+++ b/crates/parser/src/grammar/expressions.rs
@@ -22,7 +22,7 @@ pub(super) fn expr(p: &mut Parser) -> (Option<CompletedMarker>, BlockLike) {
22pub(super) fn expr_with_attrs(p: &mut Parser) -> bool { 22pub(super) fn expr_with_attrs(p: &mut Parser) -> bool {
23 let m = p.start(); 23 let m = p.start();
24 let has_attrs = p.at(T![#]); 24 let has_attrs = p.at(T![#]);
25 attributes::outer_attributes(p); 25 attributes::outer_attrs(p);
26 26
27 let (cm, _block_like) = expr(p); 27 let (cm, _block_like) = expr(p);
28 let success = cm.is_some(); 28 let success = cm.is_some();
@@ -64,7 +64,7 @@ pub(super) fn stmt(p: &mut Parser, with_semi: StmtWithSemi) {
64 // #[D] return (); 64 // #[D] return ();
65 // } 65 // }
66 let has_attrs = p.at(T![#]); 66 let has_attrs = p.at(T![#]);
67 attributes::outer_attributes(p); 67 attributes::outer_attrs(p);
68 68
69 if p.at(T![let]) { 69 if p.at(T![let]) {
70 let_stmt(p, m, with_semi); 70 let_stmt(p, m, with_semi);
@@ -175,7 +175,7 @@ pub(super) fn stmt(p: &mut Parser, with_semi: StmtWithSemi) {
175 175
176pub(super) fn expr_block_contents(p: &mut Parser) { 176pub(super) fn expr_block_contents(p: &mut Parser) {
177 // This is checked by a validator 177 // This is checked by a validator
178 attributes::inner_attributes(p); 178 attributes::inner_attrs(p);
179 179
180 while !p.at(EOF) && !p.at(T!['}']) { 180 while !p.at(EOF) && !p.at(T!['}']) {
181 // test nocontentexpr 181 // test nocontentexpr
@@ -489,7 +489,7 @@ fn method_call_expr(p: &mut Parser, lhs: CompletedMarker) -> CompletedMarker {
489 let m = lhs.precede(p); 489 let m = lhs.precede(p);
490 p.bump_any(); 490 p.bump_any();
491 name_ref(p); 491 name_ref(p);
492 type_args::opt_type_arg_list(p, true); 492 type_args::opt_generic_arg_list(p, true);
493 if p.at(T!['(']) { 493 if p.at(T!['(']) {
494 arg_list(p); 494 arg_list(p);
495 } 495 }
@@ -585,7 +585,7 @@ fn path_expr(p: &mut Parser, r: Restrictions) -> (CompletedMarker, BlockLike) {
585 paths::expr_path(p); 585 paths::expr_path(p);
586 match p.current() { 586 match p.current() {
587 T!['{'] if !r.forbid_structs => { 587 T!['{'] if !r.forbid_structs => {
588 record_field_list(p); 588 record_expr_field_list(p);
589 (m.complete(p, RECORD_EXPR), BlockLike::NotBlock) 589 (m.complete(p, RECORD_EXPR), BlockLike::NotBlock)
590 } 590 }
591 T![!] if !p.at(T![!=]) => { 591 T![!] if !p.at(T![!=]) => {
@@ -603,7 +603,7 @@ fn path_expr(p: &mut Parser, r: Restrictions) -> (CompletedMarker, BlockLike) {
603// S { x, y: 32, ..Default::default() }; 603// S { x, y: 32, ..Default::default() };
604// TupleStruct { 0: 1 }; 604// TupleStruct { 0: 1 };
605// } 605// }
606pub(crate) fn record_field_list(p: &mut Parser) { 606pub(crate) fn record_expr_field_list(p: &mut Parser) {
607 assert!(p.at(T!['{'])); 607 assert!(p.at(T!['{']));
608 let m = p.start(); 608 let m = p.start();
609 p.bump(T!['{']); 609 p.bump(T!['{']);
@@ -613,7 +613,7 @@ pub(crate) fn record_field_list(p: &mut Parser) {
613 // fn main() { 613 // fn main() {
614 // S { #[cfg(test)] field: 1 } 614 // S { #[cfg(test)] field: 1 }
615 // } 615 // }
616 attributes::outer_attributes(p); 616 attributes::outer_attrs(p);
617 617
618 match p.current() { 618 match p.current() {
619 IDENT | INT_NUMBER => { 619 IDENT | INT_NUMBER => {
diff --git a/crates/parser/src/grammar/expressions/atom.rs b/crates/parser/src/grammar/expressions/atom.rs
index 0b01d3bc6..ba6dd2fbc 100644
--- a/crates/parser/src/grammar/expressions/atom.rs
+++ b/crates/parser/src/grammar/expressions/atom.rs
@@ -75,9 +75,9 @@ pub(super) fn atom_expr(p: &mut Parser, r: Restrictions) -> Option<(CompletedMar
75 T!['('] => tuple_expr(p), 75 T!['('] => tuple_expr(p),
76 T!['['] => array_expr(p), 76 T!['['] => array_expr(p),
77 L_DOLLAR => meta_var_expr(p), 77 L_DOLLAR => meta_var_expr(p),
78 T![|] => lambda_expr(p), 78 T![|] => closure_expr(p),
79 T![move] if la == T![|] => lambda_expr(p), 79 T![move] if la == T![|] => closure_expr(p),
80 T![async] if la == T![|] || (la == T![move] && p.nth(2) == T![|]) => lambda_expr(p), 80 T![async] if la == T![|] || (la == T![move] && p.nth(2) == T![|]) => closure_expr(p),
81 T![if] => if_expr(p), 81 T![if] => if_expr(p),
82 82
83 T![loop] => loop_expr(p, None), 83 T![loop] => loop_expr(p, None),
@@ -228,7 +228,7 @@ fn array_expr(p: &mut Parser) -> CompletedMarker {
228// move || {}; 228// move || {};
229// async move || {}; 229// async move || {};
230// } 230// }
231fn lambda_expr(p: &mut Parser) -> CompletedMarker { 231fn closure_expr(p: &mut Parser) -> CompletedMarker {
232 assert!( 232 assert!(
233 p.at(T![|]) 233 p.at(T![|])
234 || (p.at(T![move]) && p.nth(1) == T![|]) 234 || (p.at(T![move]) && p.nth(1) == T![|])
@@ -239,7 +239,7 @@ fn lambda_expr(p: &mut Parser) -> CompletedMarker {
239 p.eat(T![async]); 239 p.eat(T![async]);
240 p.eat(T![move]); 240 p.eat(T![move]);
241 params::param_list_closure(p); 241 params::param_list_closure(p);
242 if opt_fn_ret_type(p) { 242 if opt_ret_type(p) {
243 // test lambda_ret_block 243 // test lambda_ret_block
244 // fn main() { || -> i32 { 92 }(); } 244 // fn main() { || -> i32 { 92 }(); }
245 block_expr(p); 245 block_expr(p);
@@ -265,7 +265,7 @@ fn if_expr(p: &mut Parser) -> CompletedMarker {
265 assert!(p.at(T![if])); 265 assert!(p.at(T![if]));
266 let m = p.start(); 266 let m = p.start();
267 p.bump(T![if]); 267 p.bump(T![if]);
268 cond(p); 268 condition(p);
269 block_expr(p); 269 block_expr(p);
270 if p.at(T![else]) { 270 if p.at(T![else]) {
271 p.bump(T![else]); 271 p.bump(T![else]);
@@ -314,7 +314,7 @@ fn while_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
314 assert!(p.at(T![while])); 314 assert!(p.at(T![while]));
315 let m = m.unwrap_or_else(|| p.start()); 315 let m = m.unwrap_or_else(|| p.start());
316 p.bump(T![while]); 316 p.bump(T![while]);
317 cond(p); 317 condition(p);
318 block_expr(p); 318 block_expr(p);
319 m.complete(p, WHILE_EXPR) 319 m.complete(p, WHILE_EXPR)
320} 320}
@@ -342,7 +342,7 @@ fn for_expr(p: &mut Parser, m: Option<Marker>) -> CompletedMarker {
342// while let Some(_) | Some(_) = None {} 342// while let Some(_) | Some(_) = None {}
343// while let | Some(_) = None {} 343// while let | Some(_) = None {}
344// } 344// }
345fn cond(p: &mut Parser) { 345fn condition(p: &mut Parser) {
346 let m = p.start(); 346 let m = p.start();
347 if p.eat(T![let]) { 347 if p.eat(T![let]) {
348 patterns::pattern_top(p); 348 patterns::pattern_top(p);
@@ -386,7 +386,7 @@ pub(crate) fn match_arm_list(p: &mut Parser) {
386 // _ => (), 386 // _ => (),
387 // } 387 // }
388 // } 388 // }
389 attributes::inner_attributes(p); 389 attributes::inner_attrs(p);
390 390
391 while !p.at(EOF) && !p.at(T!['}']) { 391 while !p.at(EOF) && !p.at(T!['}']) {
392 if p.at(T!['{']) { 392 if p.at(T!['{']) {
@@ -437,7 +437,7 @@ fn match_arm(p: &mut Parser) -> BlockLike {
437 // _ => (), 437 // _ => (),
438 // } 438 // }
439 // } 439 // }
440 attributes::outer_attributes(p); 440 attributes::outer_attrs(p);
441 441
442 patterns::pattern_top_r(p, TokenSet::EMPTY); 442 patterns::pattern_top_r(p, TokenSet::EMPTY);
443 if p.at(T![if]) { 443 if p.at(T![if]) {
diff --git a/crates/parser/src/grammar/items.rs b/crates/parser/src/grammar/items.rs
index d091b0fbb..b2f7cc21f 100644
--- a/crates/parser/src/grammar/items.rs
+++ b/crates/parser/src/grammar/items.rs
@@ -6,9 +6,9 @@ mod traits;
6mod use_item; 6mod use_item;
7 7
8pub(crate) use self::{ 8pub(crate) use self::{
9 adt::{enum_variant_list, record_field_def_list}, 9 adt::{record_field_list, variant_list},
10 expressions::{match_arm_list, record_field_list}, 10 expressions::{match_arm_list, record_expr_field_list},
11 traits::{impl_item_list, trait_item_list}, 11 traits::assoc_item_list,
12 use_item::use_tree_list, 12 use_item::use_tree_list,
13}; 13};
14use super::*; 14use super::*;
@@ -20,7 +20,7 @@ use super::*;
20// super::baz! {} 20// super::baz! {}
21// struct S; 21// struct S;
22pub(super) fn mod_contents(p: &mut Parser, stop_on_r_curly: bool) { 22pub(super) fn mod_contents(p: &mut Parser, stop_on_r_curly: bool) {
23 attributes::inner_attributes(p); 23 attributes::inner_attrs(p);
24 while !(stop_on_r_curly && p.at(T!['}']) || p.at(EOF)) { 24 while !(stop_on_r_curly && p.at(T!['}']) || p.at(EOF)) {
25 item_or_macro(p, stop_on_r_curly) 25 item_or_macro(p, stop_on_r_curly)
26 } 26 }
@@ -33,7 +33,7 @@ pub(super) const ITEM_RECOVERY_SET: TokenSet = token_set![
33 33
34pub(super) fn item_or_macro(p: &mut Parser, stop_on_r_curly: bool) { 34pub(super) fn item_or_macro(p: &mut Parser, stop_on_r_curly: bool) {
35 let m = p.start(); 35 let m = p.start();
36 attributes::outer_attributes(p); 36 attributes::outer_attrs(p);
37 let m = match maybe_item(p, m) { 37 let m = match maybe_item(p, m) {
38 Ok(()) => { 38 Ok(()) => {
39 if p.at(T![;]) { 39 if p.at(T![;]) {
@@ -144,30 +144,30 @@ pub(super) fn maybe_item(p: &mut Parser, m: Marker) -> Result<(), Marker> {
144 // test fn 144 // test fn
145 // fn foo() {} 145 // fn foo() {}
146 T![fn] => { 146 T![fn] => {
147 fn_def(p); 147 fn_(p);
148 m.complete(p, FN); 148 m.complete(p, FN);
149 } 149 }
150 150
151 // test trait 151 // test trait
152 // trait T {} 152 // trait T {}
153 T![trait] => { 153 T![trait] => {
154 traits::trait_def(p); 154 traits::trait_(p);
155 m.complete(p, TRAIT); 155 m.complete(p, TRAIT);
156 } 156 }
157 157
158 T![const] => { 158 T![const] => {
159 consts::const_def(p, m); 159 consts::konst(p, m);
160 } 160 }
161 161
162 // test impl 162 // test impl
163 // impl T for S {} 163 // impl T for S {}
164 T![impl] => { 164 T![impl] => {
165 traits::impl_def(p); 165 traits::impl_(p);
166 m.complete(p, IMPL); 166 m.complete(p, IMPL);
167 } 167 }
168 168
169 T![type] => { 169 T![type] => {
170 type_def(p, m); 170 type_alias(p, m);
171 } 171 }
172 _ => { 172 _ => {
173 if !has_visibility && !has_mods { 173 if !has_visibility && !has_mods {
@@ -190,9 +190,9 @@ fn items_without_modifiers(p: &mut Parser, m: Marker) -> Result<(), Marker> {
190 match p.current() { 190 match p.current() {
191 // test extern_crate 191 // test extern_crate
192 // extern crate foo; 192 // extern crate foo;
193 T![extern] if la == T![crate] => extern_crate_item(p, m), 193 T![extern] if la == T![crate] => extern_crate(p, m),
194 T![type] => { 194 T![type] => {
195 type_def(p, m); 195 type_alias(p, m);
196 } 196 }
197 T![mod] => mod_item(p, m), 197 T![mod] => mod_item(p, m),
198 T![struct] => { 198 T![struct] => {
@@ -205,7 +205,7 @@ fn items_without_modifiers(p: &mut Parser, m: Marker) -> Result<(), Marker> {
205 // a: i32, 205 // a: i32,
206 // b: f32, 206 // b: f32,
207 // } 207 // }
208 adt::struct_def(p, m); 208 adt::strukt(p, m);
209 } 209 }
210 // test pub_macro_def 210 // test pub_macro_def
211 // pub macro m($:ident) {} 211 // pub macro m($:ident) {}
@@ -219,12 +219,12 @@ fn items_without_modifiers(p: &mut Parser, m: Marker) -> Result<(), Marker> {
219 // a: i32, 219 // a: i32,
220 // b: f32, 220 // b: f32,
221 // } 221 // }
222 adt::union_def(p, m); 222 adt::union(p, m);
223 } 223 }
224 T![enum] => adt::enum_def(p, m), 224 T![enum] => adt::enum_(p, m),
225 T![use] => use_item::use_item(p, m), 225 T![use] => use_item::use_(p, m),
226 T![const] if (la == IDENT || la == T![_] || la == T![mut]) => consts::const_def(p, m), 226 T![const] if (la == IDENT || la == T![_] || la == T![mut]) => consts::konst(p, m),
227 T![static] => consts::static_def(p, m), 227 T![static] => consts::static_(p, m),
228 // test extern_block 228 // test extern_block
229 // extern {} 229 // extern {}
230 T![extern] 230 T![extern]
@@ -239,7 +239,7 @@ fn items_without_modifiers(p: &mut Parser, m: Marker) -> Result<(), Marker> {
239 Ok(()) 239 Ok(())
240} 240}
241 241
242fn extern_crate_item(p: &mut Parser, m: Marker) { 242fn extern_crate(p: &mut Parser, m: Marker) {
243 assert!(p.at(T![extern])); 243 assert!(p.at(T![extern]));
244 p.bump(T![extern]); 244 p.bump(T![extern]);
245 assert!(p.at(T![crate])); 245 assert!(p.at(T![crate]));
@@ -251,7 +251,7 @@ fn extern_crate_item(p: &mut Parser, m: Marker) {
251 name_ref(p); 251 name_ref(p);
252 } 252 }
253 253
254 opt_alias(p); 254 opt_rename(p);
255 p.expect(T![;]); 255 p.expect(T![;]);
256 m.complete(p, EXTERN_CRATE); 256 m.complete(p, EXTERN_CRATE);
257} 257}
@@ -265,14 +265,14 @@ pub(crate) fn extern_item_list(p: &mut Parser) {
265 m.complete(p, EXTERN_ITEM_LIST); 265 m.complete(p, EXTERN_ITEM_LIST);
266} 266}
267 267
268fn fn_def(p: &mut Parser) { 268fn fn_(p: &mut Parser) {
269 assert!(p.at(T![fn])); 269 assert!(p.at(T![fn]));
270 p.bump(T![fn]); 270 p.bump(T![fn]);
271 271
272 name_r(p, ITEM_RECOVERY_SET); 272 name_r(p, ITEM_RECOVERY_SET);
273 // test function_type_params 273 // test function_type_params
274 // fn foo<T: Clone + Copy>(){} 274 // fn foo<T: Clone + Copy>(){}
275 type_params::opt_type_param_list(p); 275 type_params::opt_generic_param_list(p);
276 276
277 if p.at(T!['(']) { 277 if p.at(T!['(']) {
278 params::param_list_fn_def(p); 278 params::param_list_fn_def(p);
@@ -282,7 +282,7 @@ fn fn_def(p: &mut Parser) {
282 // test function_ret_type 282 // test function_ret_type
283 // fn foo() {} 283 // fn foo() {}
284 // fn bar() -> () {} 284 // fn bar() -> () {}
285 opt_fn_ret_type(p); 285 opt_ret_type(p);
286 286
287 // test function_where_clause 287 // test function_where_clause
288 // fn foo<T>() where T: Copy {} 288 // fn foo<T>() where T: Copy {}
@@ -299,7 +299,7 @@ fn fn_def(p: &mut Parser) {
299 299
300// test type_item 300// test type_item
301// type Foo = Bar; 301// type Foo = Bar;
302fn type_def(p: &mut Parser, m: Marker) { 302fn type_alias(p: &mut Parser, m: Marker) {
303 assert!(p.at(T![type])); 303 assert!(p.at(T![type]));
304 p.bump(T![type]); 304 p.bump(T![type]);
305 305
@@ -307,7 +307,7 @@ fn type_def(p: &mut Parser, m: Marker) {
307 307
308 // test type_item_type_params 308 // test type_item_type_params
309 // type Result<T> = (); 309 // type Result<T> = ();
310 type_params::opt_type_param_list(p); 310 type_params::opt_generic_param_list(p);
311 311
312 if p.at(T![:]) { 312 if p.at(T![:]) {
313 type_params::bounds(p); 313 type_params::bounds(p);
@@ -329,14 +329,14 @@ pub(crate) fn mod_item(p: &mut Parser, m: Marker) {
329 329
330 name(p); 330 name(p);
331 if p.at(T!['{']) { 331 if p.at(T!['{']) {
332 mod_item_list(p); 332 item_list(p);
333 } else if !p.eat(T![;]) { 333 } else if !p.eat(T![;]) {
334 p.error("expected `;` or `{`"); 334 p.error("expected `;` or `{`");
335 } 335 }
336 m.complete(p, MODULE); 336 m.complete(p, MODULE);
337} 337}
338 338
339pub(crate) fn mod_item_list(p: &mut Parser) { 339pub(crate) fn item_list(p: &mut Parser) {
340 assert!(p.at(T!['{'])); 340 assert!(p.at(T!['{']));
341 let m = p.start(); 341 let m = p.start();
342 p.bump(T!['{']); 342 p.bump(T!['{']);
diff --git a/crates/parser/src/grammar/items/adt.rs b/crates/parser/src/grammar/items/adt.rs
index addfb59d4..67c0c5697 100644
--- a/crates/parser/src/grammar/items/adt.rs
+++ b/crates/parser/src/grammar/items/adt.rs
@@ -2,13 +2,13 @@
2 2
3use super::*; 3use super::*;
4 4
5pub(super) fn struct_def(p: &mut Parser, m: Marker) { 5pub(super) fn strukt(p: &mut Parser, m: Marker) {
6 assert!(p.at(T![struct])); 6 assert!(p.at(T![struct]));
7 p.bump(T![struct]); 7 p.bump(T![struct]);
8 struct_or_union(p, m, T![struct], STRUCT); 8 struct_or_union(p, m, T![struct], STRUCT);
9} 9}
10 10
11pub(super) fn union_def(p: &mut Parser, m: Marker) { 11pub(super) fn union(p: &mut Parser, m: Marker) {
12 assert!(p.at_contextual_kw("union")); 12 assert!(p.at_contextual_kw("union"));
13 p.bump_remap(T![union]); 13 p.bump_remap(T![union]);
14 struct_or_union(p, m, T![union], UNION); 14 struct_or_union(p, m, T![union], UNION);
@@ -16,7 +16,7 @@ pub(super) fn union_def(p: &mut Parser, m: Marker) {
16 16
17fn struct_or_union(p: &mut Parser, m: Marker, kw: SyntaxKind, def: SyntaxKind) { 17fn struct_or_union(p: &mut Parser, m: Marker, kw: SyntaxKind, def: SyntaxKind) {
18 name_r(p, ITEM_RECOVERY_SET); 18 name_r(p, ITEM_RECOVERY_SET);
19 type_params::opt_type_param_list(p); 19 type_params::opt_generic_param_list(p);
20 match p.current() { 20 match p.current() {
21 T![where] => { 21 T![where] => {
22 type_params::opt_where_clause(p); 22 type_params::opt_where_clause(p);
@@ -24,7 +24,7 @@ fn struct_or_union(p: &mut Parser, m: Marker, kw: SyntaxKind, def: SyntaxKind) {
24 T![;] => { 24 T![;] => {
25 p.bump(T![;]); 25 p.bump(T![;]);
26 } 26 }
27 T!['{'] => record_field_def_list(p), 27 T!['{'] => record_field_list(p),
28 _ => { 28 _ => {
29 //FIXME: special case `(` error message 29 //FIXME: special case `(` error message
30 p.error("expected `;` or `{`"); 30 p.error("expected `;` or `{`");
@@ -34,9 +34,9 @@ fn struct_or_union(p: &mut Parser, m: Marker, kw: SyntaxKind, def: SyntaxKind) {
34 T![;] if kw == T![struct] => { 34 T![;] if kw == T![struct] => {
35 p.bump(T![;]); 35 p.bump(T![;]);
36 } 36 }
37 T!['{'] => record_field_def_list(p), 37 T!['{'] => record_field_list(p),
38 T!['('] if kw == T![struct] => { 38 T!['('] if kw == T![struct] => {
39 tuple_field_def_list(p); 39 tuple_field_list(p);
40 // test tuple_struct_where 40 // test tuple_struct_where
41 // struct Test<T>(T) where T: Clone; 41 // struct Test<T>(T) where T: Clone;
42 // struct Test<T>(T); 42 // struct Test<T>(T);
@@ -53,21 +53,21 @@ fn struct_or_union(p: &mut Parser, m: Marker, kw: SyntaxKind, def: SyntaxKind) {
53 m.complete(p, def); 53 m.complete(p, def);
54} 54}
55 55
56pub(super) fn enum_def(p: &mut Parser, m: Marker) { 56pub(super) fn enum_(p: &mut Parser, m: Marker) {
57 assert!(p.at(T![enum])); 57 assert!(p.at(T![enum]));
58 p.bump(T![enum]); 58 p.bump(T![enum]);
59 name_r(p, ITEM_RECOVERY_SET); 59 name_r(p, ITEM_RECOVERY_SET);
60 type_params::opt_type_param_list(p); 60 type_params::opt_generic_param_list(p);
61 type_params::opt_where_clause(p); 61 type_params::opt_where_clause(p);
62 if p.at(T!['{']) { 62 if p.at(T!['{']) {
63 enum_variant_list(p); 63 variant_list(p);
64 } else { 64 } else {
65 p.error("expected `{`") 65 p.error("expected `{`")
66 } 66 }
67 m.complete(p, ENUM); 67 m.complete(p, ENUM);
68} 68}
69 69
70pub(crate) fn enum_variant_list(p: &mut Parser) { 70pub(crate) fn variant_list(p: &mut Parser) {
71 assert!(p.at(T!['{'])); 71 assert!(p.at(T!['{']));
72 let m = p.start(); 72 let m = p.start();
73 p.bump(T!['{']); 73 p.bump(T!['{']);
@@ -77,12 +77,12 @@ pub(crate) fn enum_variant_list(p: &mut Parser) {
77 continue; 77 continue;
78 } 78 }
79 let var = p.start(); 79 let var = p.start();
80 attributes::outer_attributes(p); 80 attributes::outer_attrs(p);
81 if p.at(IDENT) { 81 if p.at(IDENT) {
82 name(p); 82 name(p);
83 match p.current() { 83 match p.current() {
84 T!['{'] => record_field_def_list(p), 84 T!['{'] => record_field_list(p),
85 T!['('] => tuple_field_def_list(p), 85 T!['('] => tuple_field_list(p),
86 _ => (), 86 _ => (),
87 } 87 }
88 88
@@ -104,7 +104,7 @@ pub(crate) fn enum_variant_list(p: &mut Parser) {
104 m.complete(p, VARIANT_LIST); 104 m.complete(p, VARIANT_LIST);
105} 105}
106 106
107pub(crate) fn record_field_def_list(p: &mut Parser) { 107pub(crate) fn record_field_list(p: &mut Parser) {
108 assert!(p.at(T!['{'])); 108 assert!(p.at(T!['{']));
109 let m = p.start(); 109 let m = p.start();
110 p.bump(T!['{']); 110 p.bump(T!['{']);
@@ -128,7 +128,7 @@ pub(crate) fn record_field_def_list(p: &mut Parser) {
128 // #[serde(with = "url_serde")] 128 // #[serde(with = "url_serde")]
129 // pub uri: Uri, 129 // pub uri: Uri,
130 // } 130 // }
131 attributes::outer_attributes(p); 131 attributes::outer_attrs(p);
132 opt_visibility(p); 132 opt_visibility(p);
133 if p.at(IDENT) { 133 if p.at(IDENT) {
134 name(p); 134 name(p);
@@ -142,7 +142,7 @@ pub(crate) fn record_field_def_list(p: &mut Parser) {
142 } 142 }
143} 143}
144 144
145fn tuple_field_def_list(p: &mut Parser) { 145fn tuple_field_list(p: &mut Parser) {
146 assert!(p.at(T!['('])); 146 assert!(p.at(T!['(']));
147 let m = p.start(); 147 let m = p.start();
148 if !p.expect(T!['(']) { 148 if !p.expect(T!['(']) {
@@ -159,7 +159,7 @@ fn tuple_field_def_list(p: &mut Parser) {
159 // enum S { 159 // enum S {
160 // Uri(#[serde(with = "url_serde")] Uri), 160 // Uri(#[serde(with = "url_serde")] Uri),
161 // } 161 // }
162 attributes::outer_attributes(p); 162 attributes::outer_attrs(p);
163 opt_visibility(p); 163 opt_visibility(p);
164 if !p.at_ts(types::TYPE_FIRST) { 164 if !p.at_ts(types::TYPE_FIRST) {
165 p.error("expected a type"); 165 p.error("expected a type");
diff --git a/crates/parser/src/grammar/items/consts.rs b/crates/parser/src/grammar/items/consts.rs
index 35ad766dc..eb7d1f828 100644
--- a/crates/parser/src/grammar/items/consts.rs
+++ b/crates/parser/src/grammar/items/consts.rs
@@ -2,11 +2,11 @@
2 2
3use super::*; 3use super::*;
4 4
5pub(super) fn static_def(p: &mut Parser, m: Marker) { 5pub(super) fn static_(p: &mut Parser, m: Marker) {
6 const_or_static(p, m, T![static], STATIC) 6 const_or_static(p, m, T![static], STATIC)
7} 7}
8 8
9pub(super) fn const_def(p: &mut Parser, m: Marker) { 9pub(super) fn konst(p: &mut Parser, m: Marker) {
10 const_or_static(p, m, T![const], CONST) 10 const_or_static(p, m, T![const], CONST)
11} 11}
12 12
diff --git a/crates/parser/src/grammar/items/traits.rs b/crates/parser/src/grammar/items/traits.rs
index 751ce65f2..8394020da 100644
--- a/crates/parser/src/grammar/items/traits.rs
+++ b/crates/parser/src/grammar/items/traits.rs
@@ -5,11 +5,11 @@ use super::*;
5// test trait_item 5// test trait_item
6// trait T<U>: Hash + Clone where U: Copy {} 6// trait T<U>: Hash + Clone where U: Copy {}
7// trait X<U: Debug + Display>: Hash + Clone where U: Copy {} 7// trait X<U: Debug + Display>: Hash + Clone where U: Copy {}
8pub(super) fn trait_def(p: &mut Parser) { 8pub(super) fn trait_(p: &mut Parser) {
9 assert!(p.at(T![trait])); 9 assert!(p.at(T![trait]));
10 p.bump(T![trait]); 10 p.bump(T![trait]);
11 name_r(p, ITEM_RECOVERY_SET); 11 name_r(p, ITEM_RECOVERY_SET);
12 type_params::opt_type_param_list(p); 12 type_params::opt_generic_param_list(p);
13 // test trait_alias 13 // test trait_alias
14 // trait Z<U> = T<U>; 14 // trait Z<U> = T<U>;
15 // trait Z<U> = T<U> where U: Copy; 15 // trait Z<U> = T<U> where U: Copy;
@@ -25,41 +25,19 @@ pub(super) fn trait_def(p: &mut Parser) {
25 } 25 }
26 type_params::opt_where_clause(p); 26 type_params::opt_where_clause(p);
27 if p.at(T!['{']) { 27 if p.at(T!['{']) {
28 trait_item_list(p); 28 assoc_item_list(p);
29 } else { 29 } else {
30 p.error("expected `{`"); 30 p.error("expected `{`");
31 } 31 }
32} 32}
33 33
34// test trait_item_list
35// impl F {
36// type A: Clone;
37// const B: i32;
38// fn foo() {}
39// fn bar(&self);
40// }
41pub(crate) fn trait_item_list(p: &mut Parser) {
42 assert!(p.at(T!['{']));
43 let m = p.start();
44 p.bump(T!['{']);
45 while !p.at(EOF) && !p.at(T!['}']) {
46 if p.at(T!['{']) {
47 error_block(p, "expected an item");
48 continue;
49 }
50 item_or_macro(p, true);
51 }
52 p.expect(T!['}']);
53 m.complete(p, ASSOC_ITEM_LIST);
54}
55
56// test impl_def 34// test impl_def
57// impl Foo {} 35// impl Foo {}
58pub(super) fn impl_def(p: &mut Parser) { 36pub(super) fn impl_(p: &mut Parser) {
59 assert!(p.at(T![impl])); 37 assert!(p.at(T![impl]));
60 p.bump(T![impl]); 38 p.bump(T![impl]);
61 if choose_type_params_over_qpath(p) { 39 if choose_type_params_over_qpath(p) {
62 type_params::opt_type_param_list(p); 40 type_params::opt_generic_param_list(p);
63 } 41 }
64 42
65 // FIXME: never type 43 // FIXME: never type
@@ -74,7 +52,7 @@ pub(super) fn impl_def(p: &mut Parser) {
74 } 52 }
75 type_params::opt_where_clause(p); 53 type_params::opt_where_clause(p);
76 if p.at(T!['{']) { 54 if p.at(T!['{']) {
77 impl_item_list(p); 55 assoc_item_list(p);
78 } else { 56 } else {
79 p.error("expected `{`"); 57 p.error("expected `{`");
80 } 58 }
@@ -87,7 +65,7 @@ pub(super) fn impl_def(p: &mut Parser) {
87// fn foo() {} 65// fn foo() {}
88// fn bar(&self) {} 66// fn bar(&self) {}
89// } 67// }
90pub(crate) fn impl_item_list(p: &mut Parser) { 68pub(crate) fn assoc_item_list(p: &mut Parser) {
91 assert!(p.at(T!['{'])); 69 assert!(p.at(T!['{']));
92 let m = p.start(); 70 let m = p.start();
93 p.bump(T!['{']); 71 p.bump(T!['{']);
@@ -97,7 +75,7 @@ pub(crate) fn impl_item_list(p: &mut Parser) {
97 // //! This is a doc comment 75 // //! This is a doc comment
98 // #![doc("This is also a doc comment")] 76 // #![doc("This is also a doc comment")]
99 // } 77 // }
100 attributes::inner_attributes(p); 78 attributes::inner_attrs(p);
101 79
102 while !p.at(EOF) && !p.at(T!['}']) { 80 while !p.at(EOF) && !p.at(T!['}']) {
103 if p.at(T!['{']) { 81 if p.at(T!['{']) {
diff --git a/crates/parser/src/grammar/items/use_item.rs b/crates/parser/src/grammar/items/use_item.rs
index 8e836a77e..20e6a13cf 100644
--- a/crates/parser/src/grammar/items/use_item.rs
+++ b/crates/parser/src/grammar/items/use_item.rs
@@ -2,7 +2,7 @@
2 2
3use super::*; 3use super::*;
4 4
5pub(super) fn use_item(p: &mut Parser, m: Marker) { 5pub(super) fn use_(p: &mut Parser, m: Marker) {
6 assert!(p.at(T![use])); 6 assert!(p.at(T![use]));
7 p.bump(T![use]); 7 p.bump(T![use]);
8 use_tree(p, true); 8 use_tree(p, true);
@@ -80,7 +80,7 @@ fn use_tree(p: &mut Parser, top_level: bool) {
80 // running::out::of::synonyms::for_::different::* 80 // running::out::of::synonyms::for_::different::*
81 // }; 81 // };
82 // use Trait as _; 82 // use Trait as _;
83 opt_alias(p); 83 opt_rename(p);
84 } 84 }
85 T![:] if p.at(T![::]) => { 85 T![:] if p.at(T![::]) => {
86 p.bump(T![::]); 86 p.bump(T![::]);
diff --git a/crates/parser/src/grammar/params.rs b/crates/parser/src/grammar/params.rs
index f0da173cc..a665ffc13 100644
--- a/crates/parser/src/grammar/params.rs
+++ b/crates/parser/src/grammar/params.rs
@@ -47,20 +47,20 @@ fn list_(p: &mut Parser, flavor: Flavor) {
47 if let FnDef = flavor { 47 if let FnDef = flavor {
48 // test self_param_outer_attr 48 // test self_param_outer_attr
49 // fn f(#[must_use] self) {} 49 // fn f(#[must_use] self) {}
50 attributes::outer_attributes(p); 50 attributes::outer_attrs(p);
51 opt_self_param(p); 51 opt_self_param(p);
52 } 52 }
53 53
54 while !p.at(EOF) && !p.at(ket) { 54 while !p.at(EOF) && !p.at(ket) {
55 // test param_outer_arg 55 // test param_outer_arg
56 // fn f(#[attr1] pat: Type) {} 56 // fn f(#[attr1] pat: Type) {}
57 attributes::outer_attributes(p); 57 attributes::outer_attrs(p);
58 58
59 if !p.at_ts(VALUE_PARAMETER_FIRST) { 59 if !p.at_ts(PARAM_FIRST) {
60 p.error("expected value parameter"); 60 p.error("expected value parameter");
61 break; 61 break;
62 } 62 }
63 let param = value_parameter(p, flavor); 63 let param = param(p, flavor);
64 if !p.at(ket) { 64 if !p.at(ket) {
65 p.expect(T![,]); 65 p.expect(T![,]);
66 } 66 }
@@ -73,11 +73,11 @@ fn list_(p: &mut Parser, flavor: Flavor) {
73 m.complete(p, PARAM_LIST); 73 m.complete(p, PARAM_LIST);
74} 74}
75 75
76const VALUE_PARAMETER_FIRST: TokenSet = patterns::PATTERN_FIRST.union(types::TYPE_FIRST); 76const PARAM_FIRST: TokenSet = patterns::PATTERN_FIRST.union(types::TYPE_FIRST);
77 77
78struct Variadic(bool); 78struct Variadic(bool);
79 79
80fn value_parameter(p: &mut Parser, flavor: Flavor) -> Variadic { 80fn param(p: &mut Parser, flavor: Flavor) -> Variadic {
81 let mut res = Variadic(false); 81 let mut res = Variadic(false);
82 let m = p.start(); 82 let m = p.start();
83 match flavor { 83 match flavor {
diff --git a/crates/parser/src/grammar/paths.rs b/crates/parser/src/grammar/paths.rs
index b503af1dc..52562afa4 100644
--- a/crates/parser/src/grammar/paths.rs
+++ b/crates/parser/src/grammar/paths.rs
@@ -105,11 +105,11 @@ fn opt_path_type_args(p: &mut Parser, mode: Mode) {
105 // type F = Box<Fn(i32) -> ()>; 105 // type F = Box<Fn(i32) -> ()>;
106 if p.at(T!['(']) { 106 if p.at(T!['(']) {
107 params::param_list_fn_trait(p); 107 params::param_list_fn_trait(p);
108 opt_fn_ret_type(p); 108 opt_ret_type(p);
109 } else { 109 } else {
110 type_args::opt_type_arg_list(p, false) 110 type_args::opt_generic_arg_list(p, false)
111 } 111 }
112 } 112 }
113 Mode::Expr => type_args::opt_type_arg_list(p, true), 113 Mode::Expr => type_args::opt_generic_arg_list(p, true),
114 } 114 }
115} 115}
diff --git a/crates/parser/src/grammar/patterns.rs b/crates/parser/src/grammar/patterns.rs
index 716bdc978..07b1d6dd5 100644
--- a/crates/parser/src/grammar/patterns.rs
+++ b/crates/parser/src/grammar/patterns.rs
@@ -79,13 +79,13 @@ const PAT_RECOVERY_SET: TokenSet =
79fn atom_pat(p: &mut Parser, recovery_set: TokenSet) -> Option<CompletedMarker> { 79fn atom_pat(p: &mut Parser, recovery_set: TokenSet) -> Option<CompletedMarker> {
80 let m = match p.nth(0) { 80 let m = match p.nth(0) {
81 T![box] => box_pat(p), 81 T![box] => box_pat(p),
82 T![ref] | T![mut] => bind_pat(p, true), 82 T![ref] | T![mut] => ident_pat(p, true),
83 IDENT => match p.nth(1) { 83 IDENT => match p.nth(1) {
84 // Checks the token after an IDENT to see if a pattern is a path (Struct { .. }) or macro 84 // Checks the token after an IDENT to see if a pattern is a path (Struct { .. }) or macro
85 // (T![x]). 85 // (T![x]).
86 T!['('] | T!['{'] | T![!] => path_or_macro_pat(p), 86 T!['('] | T!['{'] | T![!] => path_or_macro_pat(p),
87 T![:] if p.nth_at(1, T![::]) => path_or_macro_pat(p), 87 T![:] if p.nth_at(1, T![::]) => path_or_macro_pat(p),
88 _ => bind_pat(p, true), 88 _ => ident_pat(p, true),
89 }, 89 },
90 90
91 // test type_path_in_pattern 91 // test type_path_in_pattern
@@ -93,8 +93,8 @@ fn atom_pat(p: &mut Parser, recovery_set: TokenSet) -> Option<CompletedMarker> {
93 _ if paths::is_path_start(p) => path_or_macro_pat(p), 93 _ if paths::is_path_start(p) => path_or_macro_pat(p),
94 _ if is_literal_pat_start(p) => literal_pat(p), 94 _ if is_literal_pat_start(p) => literal_pat(p),
95 95
96 T![.] if p.at(T![..]) => dot_dot_pat(p), 96 T![.] if p.at(T![..]) => rest_pat(p),
97 T![_] => placeholder_pat(p), 97 T![_] => wildcard_pat(p),
98 T![&] => ref_pat(p), 98 T![&] => ref_pat(p),
99 T!['('] => tuple_pat(p), 99 T!['('] => tuple_pat(p),
100 T!['['] => slice_pat(p), 100 T!['['] => slice_pat(p),
@@ -149,7 +149,7 @@ fn path_or_macro_pat(p: &mut Parser) -> CompletedMarker {
149 TUPLE_STRUCT_PAT 149 TUPLE_STRUCT_PAT
150 } 150 }
151 T!['{'] => { 151 T!['{'] => {
152 record_field_pat_list(p); 152 record_pat_field_list(p);
153 RECORD_PAT 153 RECORD_PAT
154 } 154 }
155 // test marco_pat 155 // test marco_pat
@@ -186,7 +186,7 @@ fn tuple_pat_fields(p: &mut Parser) {
186// let S { h: _, ..} = (); 186// let S { h: _, ..} = ();
187// let S { h: _, } = (); 187// let S { h: _, } = ();
188// } 188// }
189fn record_field_pat_list(p: &mut Parser) { 189fn record_pat_field_list(p: &mut Parser) {
190 assert!(p.at(T!['{'])); 190 assert!(p.at(T!['{']));
191 let m = p.start(); 191 let m = p.start();
192 p.bump(T!['{']); 192 p.bump(T!['{']);
@@ -214,7 +214,7 @@ fn record_field_pat_list(p: &mut Parser) {
214 box_pat(p); 214 box_pat(p);
215 } 215 }
216 _ => { 216 _ => {
217 bind_pat(p, false); 217 ident_pat(p, false);
218 } 218 }
219 } 219 }
220 m.complete(p, RECORD_PAT_FIELD); 220 m.complete(p, RECORD_PAT_FIELD);
@@ -230,7 +230,7 @@ fn record_field_pat_list(p: &mut Parser) {
230 230
231// test placeholder_pat 231// test placeholder_pat
232// fn main() { let _ = (); } 232// fn main() { let _ = (); }
233fn placeholder_pat(p: &mut Parser) -> CompletedMarker { 233fn wildcard_pat(p: &mut Parser) -> CompletedMarker {
234 assert!(p.at(T![_])); 234 assert!(p.at(T![_]));
235 let m = p.start(); 235 let m = p.start();
236 p.bump(T![_]); 236 p.bump(T![_]);
@@ -263,7 +263,7 @@ fn placeholder_pat(p: &mut Parser) -> CompletedMarker {
263// let [head, .., mid, tail @ ..] = (); 263// let [head, .., mid, tail @ ..] = ();
264// let [head, .., mid, .., cons] = (); 264// let [head, .., mid, .., cons] = ();
265// } 265// }
266fn dot_dot_pat(p: &mut Parser) -> CompletedMarker { 266fn rest_pat(p: &mut Parser) -> CompletedMarker {
267 assert!(p.at(T![..])); 267 assert!(p.at(T![..]));
268 let m = p.start(); 268 let m = p.start();
269 p.bump(T![..]); 269 p.bump(T![..]);
@@ -353,7 +353,7 @@ fn pat_list(p: &mut Parser, ket: SyntaxKind) {
353// let e @ _ = (); 353// let e @ _ = ();
354// let ref mut f @ g @ _ = (); 354// let ref mut f @ g @ _ = ();
355// } 355// }
356fn bind_pat(p: &mut Parser, with_at: bool) -> CompletedMarker { 356fn ident_pat(p: &mut Parser, with_at: bool) -> CompletedMarker {
357 let m = p.start(); 357 let m = p.start();
358 p.eat(T![ref]); 358 p.eat(T![ref]);
359 p.eat(T![mut]); 359 p.eat(T![mut]);
diff --git a/crates/parser/src/grammar/type_args.rs b/crates/parser/src/grammar/type_args.rs
index aef7cd6fb..f2d34a749 100644
--- a/crates/parser/src/grammar/type_args.rs
+++ b/crates/parser/src/grammar/type_args.rs
@@ -2,7 +2,7 @@
2 2
3use super::*; 3use super::*;
4 4
5pub(super) fn opt_type_arg_list(p: &mut Parser, colon_colon_required: bool) { 5pub(super) fn opt_generic_arg_list(p: &mut Parser, colon_colon_required: bool) {
6 let m; 6 let m;
7 if p.at(T![::]) && p.nth(2) == T![<] { 7 if p.at(T![::]) && p.nth(2) == T![<] {
8 m = p.start(); 8 m = p.start();
@@ -16,7 +16,7 @@ pub(super) fn opt_type_arg_list(p: &mut Parser, colon_colon_required: bool) {
16 } 16 }
17 17
18 while !p.at(EOF) && !p.at(T![>]) { 18 while !p.at(EOF) && !p.at(T![>]) {
19 type_arg(p); 19 generic_arg(p);
20 if !p.at(T![>]) && !p.expect(T![,]) { 20 if !p.at(T![>]) && !p.expect(T![,]) {
21 break; 21 break;
22 } 22 }
@@ -27,7 +27,7 @@ pub(super) fn opt_type_arg_list(p: &mut Parser, colon_colon_required: bool) {
27 27
28// test type_arg 28// test type_arg
29// type A = B<'static, i32, 1, { 2 }, Item=u64>; 29// type A = B<'static, i32, 1, { 2 }, Item=u64>;
30fn type_arg(p: &mut Parser) { 30fn generic_arg(p: &mut Parser) {
31 let m = p.start(); 31 let m = p.start();
32 match p.current() { 32 match p.current() {
33 LIFETIME => { 33 LIFETIME => {
diff --git a/crates/parser/src/grammar/type_params.rs b/crates/parser/src/grammar/type_params.rs
index 90dabb4c0..bc7d8d724 100644
--- a/crates/parser/src/grammar/type_params.rs
+++ b/crates/parser/src/grammar/type_params.rs
@@ -2,14 +2,14 @@
2 2
3use super::*; 3use super::*;
4 4
5pub(super) fn opt_type_param_list(p: &mut Parser) { 5pub(super) fn opt_generic_param_list(p: &mut Parser) {
6 if !p.at(T![<]) { 6 if !p.at(T![<]) {
7 return; 7 return;
8 } 8 }
9 type_param_list(p); 9 generic_param_list(p);
10} 10}
11 11
12fn type_param_list(p: &mut Parser) { 12fn generic_param_list(p: &mut Parser) {
13 assert!(p.at(T![<])); 13 assert!(p.at(T![<]));
14 let m = p.start(); 14 let m = p.start();
15 p.bump(T![<]); 15 p.bump(T![<]);
@@ -20,12 +20,12 @@ fn type_param_list(p: &mut Parser) {
20 // test generic_lifetime_type_attribute 20 // test generic_lifetime_type_attribute
21 // fn foo<#[derive(Lifetime)] 'a, #[derive(Type)] T>(_: &'a T) { 21 // fn foo<#[derive(Lifetime)] 'a, #[derive(Type)] T>(_: &'a T) {
22 // } 22 // }
23 attributes::outer_attributes(p); 23 attributes::outer_attrs(p);
24 24
25 match p.current() { 25 match p.current() {
26 LIFETIME => lifetime_param(p, m), 26 LIFETIME => lifetime_param(p, m),
27 IDENT => type_param(p, m), 27 IDENT => type_param(p, m),
28 CONST_KW => type_const_param(p, m), 28 CONST_KW => const_param(p, m),
29 _ => { 29 _ => {
30 m.abandon(p); 30 m.abandon(p);
31 p.err_and_bump("expected type parameter") 31 p.err_and_bump("expected type parameter")
@@ -65,7 +65,7 @@ fn type_param(p: &mut Parser, m: Marker) {
65 65
66// test const_param 66// test const_param
67// struct S<const N: u32>; 67// struct S<const N: u32>;
68fn type_const_param(p: &mut Parser, m: Marker) { 68fn const_param(p: &mut Parser, m: Marker) {
69 assert!(p.at(CONST_KW)); 69 assert!(p.at(CONST_KW));
70 p.bump(T![const]); 70 p.bump(T![const]);
71 name(p); 71 name(p);
diff --git a/crates/parser/src/grammar/types.rs b/crates/parser/src/grammar/types.rs
index 0aa173a52..c876545f4 100644
--- a/crates/parser/src/grammar/types.rs
+++ b/crates/parser/src/grammar/types.rs
@@ -32,11 +32,11 @@ fn type_with_bounds_cond(p: &mut Parser, allow_bounds: bool) {
32 match p.current() { 32 match p.current() {
33 T!['('] => paren_or_tuple_type(p), 33 T!['('] => paren_or_tuple_type(p),
34 T![!] => never_type(p), 34 T![!] => never_type(p),
35 T![*] => pointer_type(p), 35 T![*] => ptr_type(p),
36 T!['['] => array_or_slice_type(p), 36 T!['['] => array_or_slice_type(p),
37 T![&] => reference_type(p), 37 T![&] => ref_type(p),
38 T![_] => placeholder_type(p), 38 T![_] => infer_type(p),
39 T![fn] | T![unsafe] | T![extern] => fn_pointer_type(p), 39 T![fn] | T![unsafe] | T![extern] => fn_ptr_type(p),
40 T![for] => for_type(p), 40 T![for] => for_type(p),
41 T![impl] => impl_trait_type(p), 41 T![impl] => impl_trait_type(p),
42 T![dyn] => dyn_trait_type(p), 42 T![dyn] => dyn_trait_type(p),
@@ -96,7 +96,7 @@ fn never_type(p: &mut Parser) {
96 m.complete(p, NEVER_TYPE); 96 m.complete(p, NEVER_TYPE);
97} 97}
98 98
99fn pointer_type(p: &mut Parser) { 99fn ptr_type(p: &mut Parser) {
100 assert!(p.at(T![*])); 100 assert!(p.at(T![*]));
101 let m = p.start(); 101 let m = p.start();
102 p.bump(T![*]); 102 p.bump(T![*]);
@@ -156,7 +156,7 @@ fn array_or_slice_type(p: &mut Parser) {
156// type A = &(); 156// type A = &();
157// type B = &'static (); 157// type B = &'static ();
158// type C = &mut (); 158// type C = &mut ();
159fn reference_type(p: &mut Parser) { 159fn ref_type(p: &mut Parser) {
160 assert!(p.at(T![&])); 160 assert!(p.at(T![&]));
161 let m = p.start(); 161 let m = p.start();
162 p.bump(T![&]); 162 p.bump(T![&]);
@@ -168,7 +168,7 @@ fn reference_type(p: &mut Parser) {
168 168
169// test placeholder_type 169// test placeholder_type
170// type Placeholder = _; 170// type Placeholder = _;
171fn placeholder_type(p: &mut Parser) { 171fn infer_type(p: &mut Parser) {
172 assert!(p.at(T![_])); 172 assert!(p.at(T![_]));
173 let m = p.start(); 173 let m = p.start();
174 p.bump(T![_]); 174 p.bump(T![_]);
@@ -180,7 +180,7 @@ fn placeholder_type(p: &mut Parser) {
180// type B = unsafe fn(); 180// type B = unsafe fn();
181// type C = unsafe extern "C" fn(); 181// type C = unsafe extern "C" fn();
182// type D = extern "C" fn ( u8 , ... ) -> u8; 182// type D = extern "C" fn ( u8 , ... ) -> u8;
183fn fn_pointer_type(p: &mut Parser) { 183fn fn_ptr_type(p: &mut Parser) {
184 let m = p.start(); 184 let m = p.start();
185 p.eat(T![unsafe]); 185 p.eat(T![unsafe]);
186 if p.at(T![extern]) { 186 if p.at(T![extern]) {
@@ -200,7 +200,7 @@ fn fn_pointer_type(p: &mut Parser) {
200 } 200 }
201 // test fn_pointer_type_with_ret 201 // test fn_pointer_type_with_ret
202 // type F = fn() -> (); 202 // type F = fn() -> ();
203 opt_fn_ret_type(p); 203 opt_ret_type(p);
204 m.complete(p, FN_PTR_TYPE); 204 m.complete(p, FN_PTR_TYPE);
205} 205}
206 206
@@ -208,7 +208,7 @@ pub(super) fn for_binder(p: &mut Parser) {
208 assert!(p.at(T![for])); 208 assert!(p.at(T![for]));
209 p.bump(T![for]); 209 p.bump(T![for]);
210 if p.at(T![<]) { 210 if p.at(T![<]) {
211 type_params::opt_type_param_list(p); 211 type_params::opt_generic_param_list(p);
212 } else { 212 } else {
213 p.error("expected `<`"); 213 p.error("expected `<`");
214 } 214 }