Align parser names with grammar

4 files changed, 29 insertions, 51 deletions

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 @@
 
 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]));
     p.bump(T![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"));
     p.bump_remap(T![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) {
     name_r(p, ITEM_RECOVERY_SET);
-    type_params::opt_type_param_list(p);
+    type_params::opt_generic_param_list(p);
     match p.current() {
         T![where] => {
             type_params::opt_where_clause(p);
@@ -24,7 +24,7 @@ fn struct_or_union(p: &mut Parser, m: Marker, kw: SyntaxKind, def: SyntaxKind) {
                 T![;] => {
                     p.bump(T![;]);
                 }
-                T!['{'] => record_field_def_list(p),
+                T!['{'] => record_field_list(p),
                 _ => {
                     //FIXME: special case `(` error message
                     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] => {
             p.bump(T![;]);
         }
-        T!['{'] => record_field_def_list(p),
+        T!['{'] => record_field_list(p),
         T!['('] if kw == T![struct] => {
-            tuple_field_def_list(p);
+            tuple_field_list(p);
             // test tuple_struct_where
             // struct Test<T>(T) where T: Clone;
             // 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);
 }
 
-pub(super) fn enum_def(p: &mut Parser, m: Marker) {
+pub(super) fn enum_(p: &mut Parser, m: Marker) {
     assert!(p.at(T![enum]));
     p.bump(T![enum]);
     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);
     if p.at(T!['{']) {
-        enum_variant_list(p);
+        variant_list(p);
     } else {
         p.error("expected `{`")
     }
     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!['{']));
     let m = p.start();
     p.bump(T!['{']);
@@ -77,12 +77,12 @@ pub(crate) fn enum_variant_list(p: &mut Parser) {
             continue;
         }
         let var = p.start();
-        attributes::outer_attributes(p);
+        attributes::outer_attrs(p);
         if p.at(IDENT) {
             name(p);
             match p.current() {
-                T!['{'] => record_field_def_list(p),
-                T!['('] => tuple_field_def_list(p),
+                T!['{'] => record_field_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);
 }
 
-pub(crate) fn record_field_def_list(p: &mut Parser) {
+pub(crate) fn record_field_list(p: &mut Parser) {
     assert!(p.at(T!['{']));
     let m = p.start();
     p.bump(T!['{']);
@@ -128,7 +128,7 @@ pub(crate) fn record_field_def_list(p: &mut Parser) {
         //     #[serde(with = "url_serde")]
         //     pub uri: Uri,
         // }
-        attributes::outer_attributes(p);
+        attributes::outer_attrs(p);
         opt_visibility(p);
         if p.at(IDENT) {
             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!['(']));
     let m = p.start();
     if !p.expect(T!['(']) {
@@ -159,7 +159,7 @@ fn tuple_field_def_list(p: &mut Parser) {
         // enum S {
         //     Uri(#[serde(with = "url_serde")] Uri),
         // }
-        attributes::outer_attributes(p);
+        attributes::outer_attrs(p);
         opt_visibility(p);
         if !p.at_ts(types::TYPE_FIRST) {
             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 @@
 
 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)
 }
 
-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)
 }
 
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::*;
 // test trait_item
 // trait T<U>: 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]));
     p.bump(T![trait]);
     name_r(p, ITEM_RECOVERY_SET);
-    type_params::opt_type_param_list(p);
+    type_params::opt_generic_param_list(p);
     // test trait_alias
     // trait Z<U> = T<U>;
     // 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);
     if p.at(T!['{']) {
-        trait_item_list(p);
+        assoc_item_list(p);
     } else {
         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
 // impl Foo {}
-pub(super) fn impl_def(p: &mut Parser) {
+pub(super) fn impl_(p: &mut Parser) {
     assert!(p.at(T![impl]));
     p.bump(T![impl]);
     if choose_type_params_over_qpath(p) {
-        type_params::opt_type_param_list(p);
+        type_params::opt_generic_param_list(p);
     }
 
     // FIXME: never type
@@ -74,7 +52,7 @@ pub(super) fn impl_def(p: &mut Parser) {
     }
     type_params::opt_where_clause(p);
     if p.at(T!['{']) {
-        impl_item_list(p);
+        assoc_item_list(p);
     } else {
         p.error("expected `{`");
     }
@@ -87,7 +65,7 @@ pub(super) fn impl_def(p: &mut Parser) {
 //     fn foo() {}
 //     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!['{']));
     let m = p.start();
     p.bump(T!['{']);
@@ -97,7 +75,7 @@ pub(crate) fn impl_item_list(p: &mut Parser) {
     //      //! This is 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!['}']) {
         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 @@
 
 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]));
     p.bump(T![use]);
     use_tree(p, true);
@@ -80,7 +80,7 @@ fn use_tree(p: &mut Parser, top_level: bool) {
                     //  running::out::of::synonyms::for_::different::*
                     // };
                     // use Trait as _;
-                    opt_alias(p);
+                    opt_rename(p);
                 }
                 T![:] if p.at(T![::]) => {
                     p.bump(T![::]);