1 files changed, 332 insertions, 0 deletions

diff --git a/crates/libsyntax2/src/grammar/items/mod.rs b/crates/libsyntax2/src/grammar/items/mod.rs
new file mode 100644
index 000000000..3bf906f85
--- /dev/null
+++ b/crates/libsyntax2/src/grammar/items/mod.rs
@@ -0,0 +1,332 @@
+use super::*;
+
+mod consts;
+mod structs;
+mod traits;
+mod use_item;
+
+// test mod_contents
+// fn foo() {}
+// macro_rules! foo {}
+// foo::bar!();
+// super::baz! {}
+// struct S;
+pub(super) fn mod_contents(p: &mut Parser, stop_on_r_curly: bool) {
+    attributes::inner_attributes(p);
+    while !p.at(EOF) && !(stop_on_r_curly && p.at(R_CURLY)) {
+        item_or_macro(p, stop_on_r_curly)
+    }
+}
+
+pub(super) fn item_or_macro(p: &mut Parser, stop_on_r_curly: bool) {
+    let m = p.start();
+    match maybe_item(p) {
+        MaybeItem::Item(kind) => {
+            m.complete(p, kind);
+        }
+        MaybeItem::None => {
+            if paths::is_path_start(p) {
+                match macro_call(p) {
+                    BlockLike::Block => (),
+                    BlockLike::NotBlock => {
+                        p.expect(SEMI);
+                    }
+                }
+                m.complete(p, MACRO_CALL);
+            } else {
+                m.abandon(p);
+                if p.at(L_CURLY) {
+                    error_block(p, "expected an item");
+                } else if !p.at(EOF) && !(stop_on_r_curly && p.at(R_CURLY)) {
+                    p.err_and_bump("expected an item");
+                } else {
+                    p.error("expected an item");
+                }
+            }
+        }
+        MaybeItem::Modifiers => {
+            p.error("expected fn, trait or impl");
+            m.complete(p, ERROR);
+        }
+    }
+}
+
+pub(super) const ITEM_FIRST: TokenSet =
+    token_set![EXTERN_KW, MOD_KW, USE_KW, STRUCT_KW, ENUM_KW, FN_KW, PUB_KW, POUND];
+
+pub(super) enum MaybeItem {
+    None,
+    Item(SyntaxKind),
+    Modifiers,
+}
+
+pub(super) fn maybe_item(p: &mut Parser) -> MaybeItem {
+    attributes::outer_attributes(p);
+    visibility(p);
+    if let Some(kind) = items_without_modifiers(p) {
+        return MaybeItem::Item(kind);
+    }
+
+    let mut has_mods = false;
+    // modifiers
+    has_mods |= p.eat(CONST_KW);
+
+    // test unsafe_block_in_mod
+    // fn foo(){} unsafe { } fn bar(){}
+    if p.at(UNSAFE_KW) && p.nth(1) != L_CURLY {
+        p.eat(UNSAFE_KW);
+        has_mods = true;
+    }
+    if p.at(EXTERN_KW) {
+        has_mods = true;
+        abi(p);
+    }
+    if p.at(IDENT) && p.at_contextual_kw("auto") && p.nth(1) == TRAIT_KW {
+        p.bump_remap(AUTO_KW);
+        has_mods = true;
+    }
+    if p.at(IDENT) && p.at_contextual_kw("default") && p.nth(1) == IMPL_KW {
+        p.bump_remap(DEFAULT_KW);
+        has_mods = true;
+    }
+
+    // items
+    let kind = match p.current() {
+        // test extern_fn
+        // extern fn foo() {}
+
+        // test const_fn
+        // const fn foo() {}
+
+        // test const_unsafe_fn
+        // const unsafe fn foo() {}
+
+        // test unsafe_extern_fn
+        // unsafe extern "C" fn foo() {}
+
+        // test unsafe_fn
+        // unsafe fn foo() {}
+        FN_KW => {
+            function(p);
+            FUNCTION
+        }
+
+        // test unsafe_trait
+        // unsafe trait T {}
+
+        // test auto_trait
+        // auto trait T {}
+
+        // test unsafe_auto_trait
+        // unsafe auto trait T {}
+        TRAIT_KW => {
+            traits::trait_item(p);
+            TRAIT_ITEM
+        }
+
+        // test unsafe_impl
+        // unsafe impl Foo {}
+
+        // test default_impl
+        // default impl Foo {}
+
+        // test unsafe_default_impl
+        // unsafe default impl Foo {}
+        IMPL_KW => {
+            traits::impl_item(p);
+            IMPL_ITEM
+        }
+        _ => return if has_mods {
+            MaybeItem::Modifiers
+        } else {
+            MaybeItem::None
+        }
+    };
+
+    MaybeItem::Item(kind)
+}
+
+fn items_without_modifiers(p: &mut Parser) -> Option<SyntaxKind> {
+    let la = p.nth(1);
+    let kind = match p.current() {
+        // test extern_crate
+        // extern crate foo;
+        EXTERN_KW if la == CRATE_KW => {
+            extern_crate_item(p);
+            EXTERN_CRATE_ITEM
+        }
+        TYPE_KW => {
+            type_item(p);
+            TYPE_ITEM
+        }
+        MOD_KW => {
+            mod_item(p);
+            MOD_ITEM
+        }
+        STRUCT_KW => {
+            structs::struct_item(p);
+            if p.at(SEMI) {
+                p.err_and_bump(
+                    "expected item, found `;`\n\
+                     consider removing this semicolon"
+                );
+            }
+            STRUCT_ITEM
+        }
+        ENUM_KW => {
+            structs::enum_item(p);
+            ENUM_ITEM
+        }
+        USE_KW => {
+            use_item::use_item(p);
+            USE_ITEM
+        }
+        CONST_KW if (la == IDENT || la == MUT_KW) => {
+            consts::const_item(p);
+            CONST_ITEM
+        }
+        STATIC_KW => {
+            consts::static_item(p);
+            STATIC_ITEM
+        }
+        // test extern_block
+        // extern {}
+        EXTERN_KW if la == L_CURLY || ((la == STRING || la == RAW_STRING) && p.nth(2) == L_CURLY) => {
+            abi(p);
+            extern_block(p);
+            EXTERN_BLOCK_EXPR
+        }
+        _ => return None,
+    };
+    Some(kind)
+}
+
+fn extern_crate_item(p: &mut Parser) {
+    assert!(p.at(EXTERN_KW));
+    p.bump();
+    assert!(p.at(CRATE_KW));
+    p.bump();
+    name(p);
+    alias(p);
+    p.expect(SEMI);
+}
+
+fn extern_block(p: &mut Parser) {
+    assert!(p.at(L_CURLY));
+    p.bump();
+    p.expect(R_CURLY);
+}
+
+fn function(p: &mut Parser) {
+    assert!(p.at(FN_KW));
+    p.bump();
+
+    name(p);
+    // test function_type_params
+    // fn foo<T: Clone + Copy>(){}
+    type_params::type_param_list(p);
+
+    if p.at(L_PAREN) {
+        params::param_list(p);
+    } else {
+        p.error("expected function arguments");
+    }
+    // test function_ret_type
+    // fn foo() {}
+    // fn bar() -> () {}
+    fn_ret_type(p);
+
+    // test function_where_clause
+    // fn foo<T>() where T: Copy {}
+    type_params::where_clause(p);
+
+    // test fn_decl
+    // trait T { fn foo(); }
+    if !p.eat(SEMI) {
+        expressions::block(p);
+    }
+}
+
+// test type_item
+// type Foo = Bar;
+fn type_item(p: &mut Parser) {
+    assert!(p.at(TYPE_KW));
+    p.bump();
+
+    name(p);
+
+    // test type_item_type_params
+    // type Result<T> = ();
+    type_params::type_param_list(p);
+
+    if p.at(COLON) {
+        type_params::bounds(p);
+    }
+
+    // test type_item_where_clause
+    // type Foo where Foo: Copy = ();
+    type_params::where_clause(p);
+
+    if p.eat(EQ) {
+        types::type_(p);
+    }
+    p.expect(SEMI);
+}
+
+fn mod_item(p: &mut Parser) {
+    assert!(p.at(MOD_KW));
+    p.bump();
+
+    name(p);
+    if !p.eat(SEMI) {
+        if p.expect(L_CURLY) {
+            mod_contents(p, true);
+            p.expect(R_CURLY);
+        }
+    }
+}
+
+fn macro_call(p: &mut Parser) -> BlockLike {
+    assert!(paths::is_path_start(p));
+    paths::use_path(p);
+    macro_call_after_excl(p)
+}
+
+pub(super) fn macro_call_after_excl(p: &mut Parser) -> BlockLike {
+    p.expect(EXCL);
+    p.eat(IDENT);
+    let flavor = match p.current() {
+        L_CURLY => {
+            token_tree(p);
+            BlockLike::Block
+        }
+        L_PAREN | L_BRACK => {
+            token_tree(p);
+            BlockLike::NotBlock
+        }
+        _ => {
+            p.error("expected `{`, `[`, `(`");
+            BlockLike::NotBlock
+        },
+    };
+
+    flavor
+}
+
+fn token_tree(p: &mut Parser) {
+    let closing_paren_kind = match p.current() {
+        L_CURLY => R_CURLY,
+        L_PAREN => R_PAREN,
+        L_BRACK => R_BRACK,
+        _ => unreachable!(),
+    };
+    p.bump();
+    while !p.at(EOF) && !p.at(closing_paren_kind) {
+        match p.current() {
+            L_CURLY | L_PAREN | L_BRACK => token_tree(p),
+            R_CURLY | R_PAREN | R_BRACK => p.err_and_bump("unmatched brace"),
+            _ => p.bump()
+        }
+    };
+    p.expect(closing_paren_kind);
+}