From 7912189ec304b28c4df0030b5282cf3d21074154 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Tue, 31 Jul 2018 23:38:19 +0300 Subject: reorganize --- src/parser/grammar/items/consts.rs | 20 --- src/parser/grammar/items/mod.rs | 290 ----------------------------------- src/parser/grammar/items/structs.rs | 116 -------------- src/parser/grammar/items/traits.rs | 77 ---------- src/parser/grammar/items/use_item.rs | 66 -------- 5 files changed, 569 deletions(-) delete mode 100644 src/parser/grammar/items/consts.rs delete mode 100644 src/parser/grammar/items/mod.rs delete mode 100644 src/parser/grammar/items/structs.rs delete mode 100644 src/parser/grammar/items/traits.rs delete mode 100644 src/parser/grammar/items/use_item.rs (limited to 'src/parser/grammar/items') diff --git a/src/parser/grammar/items/consts.rs b/src/parser/grammar/items/consts.rs deleted file mode 100644 index ca26a7814..000000000 --- a/src/parser/grammar/items/consts.rs +++ /dev/null @@ -1,20 +0,0 @@ -use super::*; - -pub(super) fn static_item(p: &mut Parser) { - const_or_static(p, STATIC_KW) -} - -pub(super) fn const_item(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); - p.expect(EQ); - expressions::expr(p); - p.expect(SEMI); -} diff --git a/src/parser/grammar/items/mod.rs b/src/parser/grammar/items/mod.rs deleted file mode 100644 index d5f75f13d..000000000 --- a/src/parser/grammar/items/mod.rs +++ /dev/null @@ -1,290 +0,0 @@ -use super::*; - -mod consts; -mod structs; -mod traits; -mod use_item; - -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(p); - } -} - -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) fn item(p: &mut Parser) { - let item = p.start(); - attributes::outer_attributes(p); - visibility(p); - let la = p.nth(1); - let item_kind = match p.current() { - USE_KW => { - use_item::use_item(p); - USE_ITEM - } - // test extern_crate - // extern crate foo; - EXTERN_KW if la == CRATE_KW => { - extern_crate_item(p); - EXTERN_CRATE_ITEM - } - EXTERN_KW => { - abi(p); - match p.current() { - // test extern_fn - // extern fn foo() {} - FN_KW => { - fn_item(p); - FN_ITEM - } - // test extern_block - // extern {} - L_CURLY => { - extern_block(p); - EXTERN_BLOCK - } - // test extern_struct - // extern struct Foo; - _ => { - item.abandon(p); - p.error("expected `fn` or `{`"); - return; - } - } - } - STATIC_KW => { - consts::static_item(p); - STATIC_ITEM - } - CONST_KW => match p.nth(1) { - // test const_fn - // const fn foo() {} - FN_KW => { - p.bump(); - fn_item(p); - FN_ITEM - } - // test const_unsafe_fn - // const unsafe fn foo() {} - UNSAFE_KW if p.nth(2) == FN_KW => { - p.bump(); - p.bump(); - fn_item(p); - FN_ITEM - } - _ => { - consts::const_item(p); - CONST_ITEM - } - }, - UNSAFE_KW => { - p.bump(); - let la = p.nth(1); - match p.current() { - // test unsafe_trait - // unsafe trait T {} - TRAIT_KW => { - traits::trait_item(p); - TRAIT_ITEM - } - - // test unsafe_auto_trait - // unsafe auto trait T {} - IDENT if p.at_contextual_kw("auto") && la == TRAIT_KW => { - p.bump_remap(AUTO_KW); - traits::trait_item(p); - TRAIT_ITEM - } - - // test unsafe_impl - // unsafe impl Foo {} - IMPL_KW => { - traits::impl_item(p); - IMPL_ITEM - } - - // test unsafe_default_impl - // unsafe default impl Foo {} - IDENT if p.at_contextual_kw("default") && la == IMPL_KW => { - p.bump_remap(DEFAULT_KW); - traits::impl_item(p); - IMPL_ITEM - } - - // test unsafe_extern_fn - // unsafe extern "C" fn foo() {} - EXTERN_KW => { - abi(p); - if !p.at(FN_KW) { - item.abandon(p); - p.error("expected function"); - return; - } - fn_item(p); - FN_ITEM - } - - // test unsafe_fn - // unsafe fn foo() {} - FN_KW => { - fn_item(p); - FN_ITEM - } - - t => { - item.abandon(p); - let message = "expected `trait`, `impl` or `fn`"; - - // test unsafe_block_in_mod - // fn foo(){} unsafe { } fn bar(){} - if t == L_CURLY { - error_block(p, message); - } else { - p.error(message); - } - return; - } - } - } - TRAIT_KW => { - traits::trait_item(p); - TRAIT_ITEM - } - // test auto_trait - // auto trait T {} - IDENT if p.at_contextual_kw("auto") && la == TRAIT_KW => { - p.bump_remap(AUTO_KW); - traits::trait_item(p); - TRAIT_ITEM - } - IMPL_KW => { - traits::impl_item(p); - IMPL_ITEM - } - // test default_impl - // default impl Foo {} - IDENT if p.at_contextual_kw("default") && la == IMPL_KW => { - p.bump_remap(DEFAULT_KW); - traits::impl_item(p); - IMPL_ITEM - } - - FN_KW => { - fn_item(p); - FN_ITEM - } - TYPE_KW => { - type_item(p); - TYPE_ITEM - } - MOD_KW => { - mod_item(p); - MOD_ITEM - } - STRUCT_KW => { - structs::struct_item(p); - STRUCT_ITEM - } - ENUM_KW => { - structs::enum_item(p); - ENUM_ITEM - } - L_CURLY => { - item.abandon(p); - error_block(p, "expected item"); - return; - } - err_token => { - item.abandon(p); - let message = if err_token == SEMI { - //TODO: if the item is incomplete, this message is misleading - "expected item, found `;`\n\ - consider removing this semicolon" - } else { - "expected item" - }; - p.err_and_bump(message); - return; - } - }; - item.complete(p, item_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 fn_item(p: &mut Parser) { - assert!(p.at(FN_KW)); - p.bump(); - - name(p); - // test fn_item_type_params - // fn foo(){} - type_params::type_param_list(p); - - if p.at(L_PAREN) { - params::param_list(p); - } else { - p.error("expected function arguments"); - } - // test fn_item_ret_type - // fn foo() {} - // fn bar() -> () {} - fn_ret_type(p); - - // test fn_item_where_clause - // fn foo() where T: Copy {} - type_params::where_clause(p); - - 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 = (); - type_params::type_param_list(p); - - // test type_item_where_clause - // type Foo where Foo: Copy = (); - type_params::where_clause(p); - - p.expect(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); - } - } -} diff --git a/src/parser/grammar/items/structs.rs b/src/parser/grammar/items/structs.rs deleted file mode 100644 index 7ced542a4..000000000 --- a/src/parser/grammar/items/structs.rs +++ /dev/null @@ -1,116 +0,0 @@ -use super::*; - -pub(super) fn struct_item(p: &mut Parser) { - assert!(p.at(STRUCT_KW)); - p.bump(); - - name(p); - type_params::type_param_list(p); - match p.current() { - WHERE_KW => { - type_params::where_clause(p); - match p.current() { - SEMI => { - p.bump(); - return; - } - L_CURLY => named_fields(p), - _ => { - //TODO: special case `(` error message - p.error("expected `;` or `{`"); - return; - } - } - } - SEMI => { - p.bump(); - return; - } - L_CURLY => named_fields(p), - L_PAREN => { - pos_fields(p); - p.expect(SEMI); - } - _ => { - p.error("expected `;`, `{`, or `(`"); - return; - } - } -} - -pub(super) fn enum_item(p: &mut Parser) { - assert!(p.at(ENUM_KW)); - p.bump(); - name(p); - type_params::type_param_list(p); - type_params::where_clause(p); - if p.expect(L_CURLY) { - while !p.at(EOF) && !p.at(R_CURLY) { - let var = p.start(); - attributes::outer_attributes(p); - if p.at(IDENT) { - p.bump(); - match p.current() { - L_CURLY => named_fields(p), - L_PAREN => pos_fields(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); - } -} - -fn named_fields(p: &mut Parser) { - assert!(p.at(L_CURLY)); - p.bump(); - while !p.at(R_CURLY) && !p.at(EOF) { - named_field(p); - if !p.at(R_CURLY) { - p.expect(COMMA); - } - } - p.expect(R_CURLY); - - fn named_field(p: &mut Parser) { - let field = p.start(); - visibility(p); - if p.at(IDENT) { - name(p); - p.expect(COLON); - types::type_(p); - field.complete(p, NAMED_FIELD); - } else { - field.abandon(p); - p.err_and_bump("expected field declaration"); - } - } -} - -fn pos_fields(p: &mut Parser) { - if !p.expect(L_PAREN) { - return; - } - while !p.at(R_PAREN) && !p.at(EOF) { - let pos_field = p.start(); - visibility(p); - types::type_(p); - pos_field.complete(p, POS_FIELD); - - if !p.at(R_PAREN) { - p.expect(COMMA); - } - } - p.expect(R_PAREN); -} diff --git a/src/parser/grammar/items/traits.rs b/src/parser/grammar/items/traits.rs deleted file mode 100644 index bda13e565..000000000 --- a/src/parser/grammar/items/traits.rs +++ /dev/null @@ -1,77 +0,0 @@ -use super::*; - -// test trait_item -// trait T: Hash + Clone where U: Copy {} -pub(super) fn trait_item(p: &mut Parser) { - assert!(p.at(TRAIT_KW)); - p.bump(); - name(p); - type_params::type_param_list(p); - if p.at(COLON) { - type_params::bounds(p); - } - type_params::where_clause(p); - p.expect(L_CURLY); - p.expect(R_CURLY); -} - -// 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::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::where_clause(p); - p.expect(L_CURLY); - - // test impl_item_items - // impl F { - // type A = i32; - // const B: i32 = 92; - // fn foo() {} - // fn bar(&self) {} - // } - while !p.at(EOF) && !p.at(R_CURLY) { - item(p); - } - p.expect(R_CURLY); -} - -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 ::absolute::Path { ... }`) - // because this is what almost always expected in practice, qualified paths in impls - // (`impl ::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/src/parser/grammar/items/use_item.rs b/src/parser/grammar/items/use_item.rs deleted file mode 100644 index a3f7f0da8..000000000 --- a/src/parser/grammar/items/use_item.rs +++ /dev/null @@ -1,66 +0,0 @@ -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(); - } - nested_trees(p); - } - _ if paths::is_path_start(p) => { - paths::use_path(p); - match p.current() { - AS_KW => { - alias(p); - } - COLONCOLON => { - p.bump(); - match p.current() { - STAR => { - p.bump(); - } - L_CURLY => nested_trees(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); -} - -fn nested_trees(p: &mut Parser) { - assert!(p.at(L_CURLY)); - 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); -} -- cgit v1.2.3