From d334b5a1db9ec6a57f54077d422a3f4b3c8c1178 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Thu, 21 Feb 2019 13:27:45 +0300 Subject: move parser to a separate crate --- crates/ra_parser/src/grammar/items.rs | 392 ++++++++++++++++++++++++++++++++++ 1 file changed, 392 insertions(+) create mode 100644 crates/ra_parser/src/grammar/items.rs (limited to 'crates/ra_parser/src/grammar/items.rs') diff --git a/crates/ra_parser/src/grammar/items.rs b/crates/ra_parser/src/grammar/items.rs new file mode 100644 index 000000000..4b962c1f3 --- /dev/null +++ b/crates/ra_parser/src/grammar/items.rs @@ -0,0 +1,392 @@ +mod consts; +mod nominal; +mod traits; +mod use_item; + +pub(crate) use self::{ + expressions::{match_arm_list, named_field_list}, + nominal::{enum_variant_list, named_field_def_list}, + traits::{impl_item_list, trait_item_list}, + use_item::use_tree_list, +}; +use super::*; + +// 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, +} + +pub(super) 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(); + attributes::outer_attributes(p); + 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 { + 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_err 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_block(p); + IMPL_BLOCK + } + _ => { + return if has_mods { MaybeItem::Modifiers } else { MaybeItem::None }; + } + }; + + MaybeItem::Item(kind) +} + +fn items_without_modifiers(p: &mut Parser) -> Option { + 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") && p.nth(1) == IDENT => { + // 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_ref(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(){} + 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() 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 = (); + 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); + if p.at(IDENT) { + name(p); + } + match p.current() { + L_CURLY => { + token_tree(p); + BlockLike::Block + } + L_PAREN | L_BRACK => { + token_tree(p); + BlockLike::NotBlock + } + _ => { + p.error("expected `{`, `[`, `(`"); + BlockLike::NotBlock + } + } +} + +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); +} -- cgit v1.2.3