1 files changed, 184 insertions, 0 deletions

diff --git a/crates/ra_syntax/src/grammar.rs b/crates/ra_syntax/src/grammar.rs
new file mode 100644
index 000000000..06a37d648
--- /dev/null
+++ b/crates/ra_syntax/src/grammar.rs
@@ -0,0 +1,184 @@
+//! This is the actual "grammar" of the Rust language.
+//!
+//! Each function in this module and its children corresponds
+//! to a production of the format grammar. Submodules roughly
+//! correspond to different *areas* of the grammar. By convention,
+//! each submodule starts with `use super::*` import and exports
+//! "public" productions via `pub(super)`.
+//!
+//! See docs for `Parser` to learn about API, available to the grammar,
+//! and see docs for `Event` to learn how this actually manages to
+//! produce parse trees.
+//!
+//! Code in this module also contains inline tests, which start with
+//! `// test name-of-the-test` comment and look like this:
+//!
+//! ```
+//! // test function_with_zero_parameters
+//! // fn foo() {}
+//! ```
+//!
+//! After adding a new inline-test, run `cargo collect-tests` to extract
+//! it as a standalone text-fixture into `tests/data/parser/inline`, and
+//! run `cargo test` once to create the "gold" value.
+//!
+//! Coding convention: rules like `where_clause` always produce either a
+//! node or an error, rules like `opt_where_clause` may produce nothing.
+//! Non-opt rules typically start with `assert!(p.at(FIRST_TOKEN))`, the
+//! caller is responsible for branching on the first token.
+mod attributes;
+mod expressions;
+mod items;
+mod params;
+mod paths;
+mod patterns;
+mod type_args;
+mod type_params;
+mod types;
+
+pub(crate) use self::{
+    expressions::block,
+    items::{
+        enum_variant_list, extern_item_list, impl_item_list, match_arm_list, mod_item_list,
+        named_field_def_list, named_field_list, token_tree, trait_item_list, use_tree_list,
+    },
+};
+use crate::{
+    parser_api::{CompletedMarker, Marker, Parser},
+    token_set::TokenSet,
+    SyntaxKind::{self, *},
+};
+
+pub(crate) fn root(p: &mut Parser) {
+    let m = p.start();
+    p.eat(SHEBANG);
+    items::mod_contents(p, false);
+    m.complete(p, SOURCE_FILE);
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum BlockLike {
+    Block,
+    NotBlock,
+}
+
+impl BlockLike {
+    fn is_block(self) -> bool {
+        self == BlockLike::Block
+    }
+}
+
+fn opt_visibility(p: &mut Parser) {
+    match p.current() {
+        PUB_KW => {
+            let m = p.start();
+            p.bump();
+            if p.at(L_PAREN) {
+                match p.nth(1) {
+                    // test crate_visibility
+                    // pub(crate) struct S;
+                    // pub(self) struct S;
+                    // pub(self) struct S;
+                    // pub(self) struct S;
+                    CRATE_KW | SELF_KW | SUPER_KW => {
+                        p.bump();
+                        p.bump();
+                        p.expect(R_PAREN);
+                    }
+                    IN_KW => {
+                        p.bump();
+                        p.bump();
+                        paths::use_path(p);
+                        p.expect(R_PAREN);
+                    }
+                    _ => (),
+                }
+            }
+            m.complete(p, VISIBILITY);
+        }
+        // test crate_keyword_vis
+        // crate fn main() { }
+        CRATE_KW => {
+            let m = p.start();
+            p.bump();
+            m.complete(p, VISIBILITY);
+        }
+        _ => (),
+    }
+}
+
+fn opt_alias(p: &mut Parser) {
+    if p.at(AS_KW) {
+        let m = p.start();
+        p.bump();
+        name(p);
+        m.complete(p, ALIAS);
+    }
+}
+
+fn abi(p: &mut Parser) {
+    assert!(p.at(EXTERN_KW));
+    let abi = p.start();
+    p.bump();
+    match p.current() {
+        STRING | RAW_STRING => p.bump(),
+        _ => (),
+    }
+    abi.complete(p, ABI);
+}
+
+fn opt_fn_ret_type(p: &mut Parser) -> bool {
+    if p.at(THIN_ARROW) {
+        let m = p.start();
+        p.bump();
+        types::type_(p);
+        m.complete(p, RET_TYPE);
+        true
+    } else {
+        false
+    }
+}
+
+fn name_r(p: &mut Parser, recovery: TokenSet) {
+    if p.at(IDENT) {
+        let m = p.start();
+        p.bump();
+        m.complete(p, NAME);
+    } else {
+        p.err_recover("expected a name", recovery);
+    }
+}
+
+fn name(p: &mut Parser) {
+    name_r(p, TokenSet::EMPTY)
+}
+
+fn name_ref(p: &mut Parser) {
+    if p.at(IDENT) {
+        let m = p.start();
+        p.bump();
+        m.complete(p, NAME_REF);
+    } else {
+        p.err_and_bump("expected identifier");
+    }
+}
+
+fn error_block(p: &mut Parser, message: &str) {
+    go(p, Some(message));
+    fn go(p: &mut Parser, message: Option<&str>) {
+        assert!(p.at(L_CURLY));
+        let m = p.start();
+        if let Some(message) = message {
+            p.error(message);
+        }
+        p.bump();
+        while !p.at(EOF) && !p.at(R_CURLY) {
+            match p.current() {
+                L_CURLY => go(p, None),
+                _ => p.bump(),
+            }
+        }
+        p.eat(R_CURLY);
+        m.complete(p, ERROR);
+    }
+}