rename all things

5 files changed, 753 insertions, 0 deletions

diff --git a/crates/ra_syntax/src/grammar/items/consts.rs b/crates/ra_syntax/src/grammar/items/consts.rs
new file mode 100644
index 000000000..5a5852f83
--- /dev/null
+++ b/crates/ra_syntax/src/grammar/items/consts.rs
@@ -0,0 +1,21 @@
+use super::*;
+
+pub(super) fn static_def(p: &mut Parser) {
+    const_or_static(p, STATIC_KW)
+}
+
+pub(super) fn const_def(p: &mut Parser) {
+    const_or_static(p, CONST_KW)
+}
+
+fn const_or_static(p: &mut Parser, kw: SyntaxKind) {
+    assert!(p.at(kw));
+    p.bump();
+    p.eat(MUT_KW); // TODO: validator to forbid const mut
+    name(p);
+    types::ascription(p);
+    if p.eat(EQ) {
+        expressions::expr(p);
+    }
+    p.expect(SEMI);
+}
diff --git a/crates/ra_syntax/src/grammar/items/mod.rs b/crates/ra_syntax/src/grammar/items/mod.rs
new file mode 100644
index 000000000..2567313ab
--- /dev/null
+++ b/crates/ra_syntax/src/grammar/items/mod.rs
@@ -0,0 +1,393 @@
+
+mod consts;
+mod nominal;
+mod traits;
+mod use_item;
+
+use super::*;
+pub(crate) use self::{
+    expressions::{named_field_list, match_arm_list},
+    nominal::{enum_variant_list, named_field_def_list},
+    traits::{trait_item_list, impl_item_list},
+    use_item::use_tree_list,
+};
+
+// 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, ItemFlavor::Mod)
+    }
+}
+
+pub(super) enum ItemFlavor {
+    Mod, Trait
+}
+
+const ITEM_RECOVERY_SET: TokenSet =
+    token_set![FN_KW, STRUCT_KW, ENUM_KW, IMPL_KW, TRAIT_KW, CONST_KW, STATIC_KW, LET_KW,
+               MOD_KW, PUB_KW, CRATE_KW];
+
+pub(super) fn item_or_macro(p: &mut Parser, stop_on_r_curly: bool, flavor: ItemFlavor) {
+    let m = p.start();
+    match maybe_item(p, flavor) {
+        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(R_CURLY) && !stop_on_r_curly {
+                    let e = p.start();
+                    p.error("unmatched `}`");
+                    p.bump();
+                    e.complete(p, ERROR);
+                } else if !p.at(EOF) && !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) enum MaybeItem {
+    None,
+    Item(SyntaxKind),
+    Modifiers,
+}
+
+pub(super) fn maybe_item(p: &mut Parser, flavor: ItemFlavor) -> MaybeItem {
+    attributes::outer_attributes(p);
+    opt_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 => {
+            fn_def(p, flavor);
+            FN_DEF
+        }
+
+        // test unsafe_trait
+        // unsafe trait T {}
+
+        // test auto_trait
+        // auto trait T {}
+
+        // test unsafe_auto_trait
+        // unsafe auto trait T {}
+        TRAIT_KW => {
+            traits::trait_def(p);
+            TRAIT_DEF
+        }
+
+        // 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_def(p);
+            TYPE_DEF
+        }
+        MOD_KW => {
+            mod_item(p);
+            MODULE
+        }
+        STRUCT_KW => {
+            // test struct_items
+            // struct Foo;
+            // struct Foo {}
+            // struct Foo();
+            // struct Foo(String, usize);
+            // struct Foo {
+            //     a: i32,
+            //     b: f32,
+            // }
+            nominal::struct_def(p, STRUCT_KW);
+            if p.at(SEMI) {
+                p.err_and_bump(
+                    "expected item, found `;`\n\
+                     consider removing this semicolon"
+                );
+            }
+            STRUCT_DEF
+        }
+        IDENT if p.at_contextual_kw("union") => {
+            // test union_items
+            // union Foo {}
+            // union Foo {
+            //     a: i32,
+            //     b: f32,
+            // }
+            nominal::struct_def(p, UNION_KW);
+            STRUCT_DEF
+        }
+        ENUM_KW => {
+            nominal::enum_def(p);
+            ENUM_DEF
+        }
+        USE_KW => {
+            use_item::use_item(p);
+            USE_ITEM
+        }
+        CONST_KW if (la == IDENT || la == MUT_KW) => {
+            consts::const_def(p);
+            CONST_DEF
+        }
+        STATIC_KW => {
+            consts::static_def(p);
+            STATIC_DEF
+        }
+        // test extern_block
+        // extern {}
+        EXTERN_KW if la == L_CURLY || ((la == STRING || la == RAW_STRING) && p.nth(2) == L_CURLY) => {
+            abi(p);
+            extern_item_list(p);
+            EXTERN_BLOCK
+        }
+        _ => 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);
+    opt_alias(p);
+    p.expect(SEMI);
+}
+
+pub(crate) fn extern_item_list(p: &mut Parser) {
+    assert!(p.at(L_CURLY));
+    let m = p.start();
+    p.bump();
+    mod_contents(p, true);
+    p.expect(R_CURLY);
+    m.complete(p, EXTERN_ITEM_LIST);
+}
+
+fn fn_def(p: &mut Parser, flavor: ItemFlavor) {
+    assert!(p.at(FN_KW));
+    p.bump();
+
+    name_r(p, ITEM_RECOVERY_SET);
+    // test function_type_params
+    // fn foo<T: Clone + Copy>(){}
+    type_params::opt_type_param_list(p);
+
+    if p.at(L_PAREN) {
+        match flavor {
+            ItemFlavor::Mod =>
+                params::param_list(p),
+            ItemFlavor::Trait =>
+                params::param_list_opt_patterns(p),
+        }
+    } else {
+        p.error("expected function arguments");
+    }
+    // test function_ret_type
+    // fn foo() {}
+    // fn bar() -> () {}
+    opt_fn_ret_type(p);
+
+    // test function_where_clause
+    // fn foo<T>() where T: Copy {}
+    type_params::opt_where_clause(p);
+
+    // test fn_decl
+    // trait T { fn foo(); }
+    if p.at(SEMI) {
+        p.bump();
+    } else {
+        expressions::block(p)
+    }
+}
+
+// test type_item
+// type Foo = Bar;
+fn type_def(p: &mut Parser) {
+    assert!(p.at(TYPE_KW));
+    p.bump();
+
+    name(p);
+
+    // test type_item_type_params
+    // type Result<T> = ();
+    type_params::opt_type_param_list(p);
+
+    if p.at(COLON) {
+        type_params::bounds(p);
+    }
+
+    // test type_item_where_clause
+    // type Foo where Foo: Copy = ();
+    type_params::opt_where_clause(p);
+
+    if p.eat(EQ) {
+        types::type_(p);
+    }
+    p.expect(SEMI);
+}
+
+pub(crate) fn mod_item(p: &mut Parser) {
+    assert!(p.at(MOD_KW));
+    p.bump();
+
+    name(p);
+    if p.at(L_CURLY) {
+        mod_item_list(p);
+    } else if !p.eat(SEMI) {
+        p.error("expected `;` or `{`");
+    }
+}
+
+pub(crate) fn mod_item_list(p: &mut Parser) {
+    assert!(p.at(L_CURLY));
+    let m = p.start();
+    p.bump();
+    mod_contents(p, true);
+    p.expect(R_CURLY);
+    m.complete(p, ITEM_LIST);
+}
+
+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
+}
+
+pub(crate) 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!(),
+    };
+    let m = p.start();
+    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 => {
+                p.error("unmatched `}`");
+                m.complete(p, TOKEN_TREE);
+                return;
+            }
+            R_PAREN | R_BRACK => p.err_and_bump("unmatched brace"),
+            _ => p.bump()
+        }
+    };
+    p.expect(closing_paren_kind);
+    m.complete(p, TOKEN_TREE);
+}
diff --git a/crates/ra_syntax/src/grammar/items/nominal.rs b/crates/ra_syntax/src/grammar/items/nominal.rs
new file mode 100644
index 000000000..8d02ad555
--- /dev/null
+++ b/crates/ra_syntax/src/grammar/items/nominal.rs
@@ -0,0 +1,154 @@
+use super::*;
+
+pub(super) fn struct_def(p: &mut Parser, kind: SyntaxKind) {
+    assert!(p.at(STRUCT_KW) || p.at_contextual_kw("union"));
+    p.bump_remap(kind);
+
+    name_r(p, ITEM_RECOVERY_SET);
+    type_params::opt_type_param_list(p);
+    match p.current() {
+        WHERE_KW => {
+            type_params::opt_where_clause(p);
+            match p.current() {
+                SEMI => {
+                    p.bump();
+                    return;
+                }
+                L_CURLY => named_field_def_list(p),
+                _ => {
+                    //TODO: special case `(` error message
+                    p.error("expected `;` or `{`");
+                    return;
+                }
+            }
+        }
+        SEMI if kind == STRUCT_KW => {
+            p.bump();
+            return;
+        }
+        L_CURLY => named_field_def_list(p),
+        L_PAREN if kind == STRUCT_KW => {
+            pos_field_list(p);
+            p.expect(SEMI);
+        }
+        _ if kind == STRUCT_KW => {
+            p.error("expected `;`, `{`, or `(`");
+            return;
+        }
+        _ => {
+            p.error("expected `{`");
+            return;
+        }
+    }
+}
+
+pub(super) fn enum_def(p: &mut Parser) {
+    assert!(p.at(ENUM_KW));
+    p.bump();
+    name_r(p, ITEM_RECOVERY_SET);
+    type_params::opt_type_param_list(p);
+    type_params::opt_where_clause(p);
+    if p.at(L_CURLY) {
+        enum_variant_list(p);
+    } else {
+        p.error("expected `{`")
+    }
+}
+
+pub(crate) fn enum_variant_list(p: &mut Parser) {
+    assert!(p.at(L_CURLY));
+    let m = p.start();
+    p.bump();
+    while !p.at(EOF) && !p.at(R_CURLY) {
+        if p.at(L_CURLY) {
+            error_block(p, "expected enum variant");
+            continue;
+        }
+        let var = p.start();
+        attributes::outer_attributes(p);
+        if p.at(IDENT) {
+            name(p);
+            match p.current() {
+                L_CURLY => named_field_def_list(p),
+                L_PAREN => pos_field_list(p),
+                EQ => {
+                    p.bump();
+                    expressions::expr(p);
+                }
+                _ => (),
+            }
+            var.complete(p, ENUM_VARIANT);
+        } else {
+            var.abandon(p);
+            p.err_and_bump("expected enum variant");
+        }
+        if !p.at(R_CURLY) {
+            p.expect(COMMA);
+        }
+    }
+    p.expect(R_CURLY);
+    m.complete(p, ENUM_VARIANT_LIST);
+}
+
+pub(crate) fn named_field_def_list(p: &mut Parser) {
+    assert!(p.at(L_CURLY));
+    let m = p.start();
+    p.bump();
+    while !p.at(R_CURLY) && !p.at(EOF) {
+        if p.at(L_CURLY) {
+            error_block(p, "expected field");
+            continue;
+        }
+        named_field_def(p);
+        if !p.at(R_CURLY) {
+            p.expect(COMMA);
+        }
+    }
+    p.expect(R_CURLY);
+    m.complete(p, NAMED_FIELD_DEF_LIST);
+
+    fn named_field_def(p: &mut Parser) {
+        let m = p.start();
+        // test field_attrs
+        // struct S {
+        //     #[serde(with = "url_serde")]
+        //     pub uri: Uri,
+        // }
+        attributes::outer_attributes(p);
+        opt_visibility(p);
+        if p.at(IDENT) {
+            name(p);
+            p.expect(COLON);
+            types::type_(p);
+            m.complete(p, NAMED_FIELD_DEF);
+        } else {
+            m.abandon(p);
+            p.err_and_bump("expected field declaration");
+        }
+    }
+}
+
+fn pos_field_list(p: &mut Parser) {
+    assert!(p.at(L_PAREN));
+    let m = p.start();
+    if !p.expect(L_PAREN) {
+        return;
+    }
+    while !p.at(R_PAREN) && !p.at(EOF) {
+        let m = p.start();
+        opt_visibility(p);
+        if !p.at_ts(types::TYPE_FIRST) {
+            p.error("expected a type");
+            m.complete(p, ERROR);
+            break;
+        }
+        types::type_(p);
+        m.complete(p, POS_FIELD);
+
+        if !p.at(R_PAREN) {
+            p.expect(COMMA);
+        }
+    }
+    p.expect(R_PAREN);
+    m.complete(p, POS_FIELD_LIST);
+}
diff --git a/crates/ra_syntax/src/grammar/items/traits.rs b/crates/ra_syntax/src/grammar/items/traits.rs
new file mode 100644
index 000000000..c21cfb1a9
--- /dev/null
+++ b/crates/ra_syntax/src/grammar/items/traits.rs
@@ -0,0 +1,117 @@
+use super::*;
+
+// test trait_item
+// trait T<U>: Hash + Clone where U: Copy {}
+pub(super) fn trait_def(p: &mut Parser) {
+    assert!(p.at(TRAIT_KW));
+    p.bump();
+    name_r(p, ITEM_RECOVERY_SET);
+    type_params::opt_type_param_list(p);
+    if p.at(COLON) {
+        type_params::bounds(p);
+    }
+    type_params::opt_where_clause(p);
+    if p.at(L_CURLY) {
+        trait_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(L_CURLY));
+    let m = p.start();
+    p.bump();
+    while !p.at(EOF) && !p.at(R_CURLY) {
+        if p.at(L_CURLY) {
+            error_block(p, "expected an item");
+            continue;
+        }
+        item_or_macro(p, true, ItemFlavor::Trait);
+    }
+    p.expect(R_CURLY);
+    m.complete(p, ITEM_LIST);
+}
+
+// test impl_item
+// impl Foo {}
+pub(super) fn impl_item(p: &mut Parser) {
+    assert!(p.at(IMPL_KW));
+    p.bump();
+    if choose_type_params_over_qpath(p) {
+        type_params::opt_type_param_list(p);
+    }
+
+    // TODO: never type
+    // impl ! {}
+
+    // test impl_item_neg
+    // impl !Send for X {}
+    p.eat(EXCL);
+    types::type_(p);
+    if p.eat(FOR_KW) {
+        types::type_(p);
+    }
+    type_params::opt_where_clause(p);
+    if p.at(L_CURLY) {
+        impl_item_list(p);
+    } else {
+        p.error("expected `{`");
+    }
+}
+
+// test impl_item_list
+// impl F {
+//     type A = i32;
+//     const B: i32 = 92;
+//     fn foo() {}
+//     fn bar(&self) {}
+// }
+pub(crate) fn impl_item_list(p: &mut Parser) {
+    assert!(p.at(L_CURLY));
+    let m = p.start();
+    p.bump();
+
+    while !p.at(EOF) && !p.at(R_CURLY) {
+        if p.at(L_CURLY) {
+            error_block(p, "expected an item");
+            continue;
+        }
+        item_or_macro(p, true, ItemFlavor::Mod);
+    }
+    p.expect(R_CURLY);
+    m.complete(p, ITEM_LIST);
+}
+
+fn choose_type_params_over_qpath(p: &Parser) -> bool {
+    // There's an ambiguity between generic parameters and qualified paths in impls.
+    // If we see `<` it may start both, so we have to inspect some following tokens.
+    // The following combinations can only start generics,
+    // but not qualified paths (with one exception):
+    //     `<` `>` - empty generic parameters
+    //     `<` `#` - generic parameters with attributes
+    //     `<` (LIFETIME|IDENT) `>` - single generic parameter
+    //     `<` (LIFETIME|IDENT) `,` - first generic parameter in a list
+    //     `<` (LIFETIME|IDENT) `:` - generic parameter with bounds
+    //     `<` (LIFETIME|IDENT) `=` - generic parameter with a default
+    // The only truly ambiguous case is
+    //     `<` IDENT `>` `::` IDENT ...
+    // we disambiguate it in favor of generics (`impl<T> ::absolute::Path<T> { ... }`)
+    // because this is what almost always expected in practice, qualified paths in impls
+    // (`impl <Type>::AssocTy { ... }`) aren't even allowed by type checker at the moment.
+    if !p.at(L_ANGLE) {
+        return false;
+    }
+    if p.nth(1) == POUND || p.nth(1) == R_ANGLE {
+        return true;
+    }
+    (p.nth(1) == LIFETIME || p.nth(1) == IDENT)
+        && (p.nth(2) == R_ANGLE || p.nth(2) == COMMA || p.nth(2) == COLON || p.nth(2) == EQ)
+}
diff --git a/crates/ra_syntax/src/grammar/items/use_item.rs b/crates/ra_syntax/src/grammar/items/use_item.rs
new file mode 100644
index 000000000..1ee4349fd
--- /dev/null
+++ b/crates/ra_syntax/src/grammar/items/use_item.rs
@@ -0,0 +1,68 @@
+use super::*;
+
+pub(super) fn use_item(p: &mut Parser) {
+    assert!(p.at(USE_KW));
+    p.bump();
+    use_tree(p);
+    p.expect(SEMI);
+}
+
+fn use_tree(p: &mut Parser) {
+    let la = p.nth(1);
+    let m = p.start();
+    match (p.current(), la) {
+        (STAR, _) => p.bump(),
+        (COLONCOLON, STAR) => {
+            p.bump();
+            p.bump();
+        }
+        (L_CURLY, _) | (COLONCOLON, L_CURLY) => {
+            if p.at(COLONCOLON) {
+                p.bump();
+            }
+            use_tree_list(p);
+        }
+        _ if paths::is_path_start(p) => {
+            paths::use_path(p);
+            match p.current() {
+                AS_KW => {
+                    opt_alias(p);
+                }
+                COLONCOLON => {
+                    p.bump();
+                    match p.current() {
+                        STAR => {
+                            p.bump();
+                        }
+                        L_CURLY => use_tree_list(p),
+                        _ => {
+                            // is this unreachable?
+                            p.error("expected `{` or `*`");
+                        }
+                    }
+                }
+                _ => (),
+            }
+        }
+        _ => {
+            m.abandon(p);
+            p.err_and_bump("expected one of `*`, `::`, `{`, `self`, `super`, `indent`");
+            return;
+        }
+    }
+    m.complete(p, USE_TREE);
+}
+
+pub(crate) fn use_tree_list(p: &mut Parser) {
+    assert!(p.at(L_CURLY));
+    let m = p.start();
+    p.bump();
+    while !p.at(EOF) && !p.at(R_CURLY) {
+        use_tree(p);
+        if !p.at(R_CURLY) {
+            p.expect(COMMA);
+        }
+    }
+    p.expect(R_CURLY);
+    m.complete(p, USE_TREE_LIST);
+}