2018-02-11 08:58:22 -06:00
|
|
|
//! 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:
|
|
|
|
//!
|
|
|
|
//! ```
|
2018-08-09 09:44:40 -05:00
|
|
|
//! // test function_with_zero_parameters
|
2018-02-11 08:58:22 -06:00
|
|
|
//! // 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.
|
2018-11-05 02:24:02 -06:00
|
|
|
//!
|
|
|
|
//! 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.
|
2018-01-07 12:46:10 -06:00
|
|
|
mod attributes;
|
|
|
|
mod expressions;
|
2018-07-30 06:08:06 -05:00
|
|
|
mod items;
|
2018-07-31 15:38:19 -05:00
|
|
|
mod params;
|
2018-01-09 14:32:18 -06:00
|
|
|
mod paths;
|
2018-07-30 06:08:06 -05:00
|
|
|
mod patterns;
|
2018-07-31 15:13:08 -05:00
|
|
|
mod type_args;
|
2018-07-31 15:38:19 -05:00
|
|
|
mod type_params;
|
2018-07-30 06:08:06 -05:00
|
|
|
mod types;
|
2018-01-01 09:58:46 -06:00
|
|
|
|
2018-10-15 16:44:23 -05:00
|
|
|
use crate::{
|
|
|
|
SyntaxKind::{self, *},
|
2019-02-21 04:27:45 -06:00
|
|
|
TokenSet,
|
|
|
|
parser::{CompletedMarker, Marker, Parser},
|
2018-10-15 16:44:23 -05:00
|
|
|
};
|
2018-07-29 07:16:07 -05:00
|
|
|
|
2019-02-21 04:27:45 -06:00
|
|
|
pub(crate) fn root(p: &mut Parser) {
|
2018-08-25 06:45:17 -05:00
|
|
|
let m = p.start();
|
2018-01-20 08:21:13 -06:00
|
|
|
p.eat(SHEBANG);
|
2018-01-28 03:57:03 -06:00
|
|
|
items::mod_contents(p, false);
|
2018-11-07 09:38:43 -06:00
|
|
|
m.complete(p, SOURCE_FILE);
|
2018-01-01 09:58:46 -06:00
|
|
|
}
|
|
|
|
|
2019-04-18 13:47:29 -05:00
|
|
|
pub(crate) fn macro_items(p: &mut Parser) {
|
|
|
|
let m = p.start();
|
|
|
|
items::mod_contents(p, false);
|
|
|
|
m.complete(p, MACRO_ITEMS);
|
|
|
|
}
|
|
|
|
|
2019-04-18 14:49:56 -05:00
|
|
|
pub(crate) fn macro_stmts(p: &mut Parser) {
|
|
|
|
let m = p.start();
|
|
|
|
|
|
|
|
while !p.at(EOF) {
|
|
|
|
if p.current() == SEMI {
|
|
|
|
p.bump();
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
expressions::stmt(p, expressions::StmtWithSemi::Optional);
|
|
|
|
}
|
|
|
|
|
|
|
|
m.complete(p, MACRO_STMTS);
|
|
|
|
}
|
|
|
|
|
2019-04-06 07:14:28 -05:00
|
|
|
pub(crate) fn path(p: &mut Parser) {
|
|
|
|
paths::type_path(p);
|
|
|
|
}
|
|
|
|
|
2019-04-13 05:38:31 -05:00
|
|
|
pub(crate) fn expr(p: &mut Parser) {
|
|
|
|
expressions::expr(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn type_(p: &mut Parser) {
|
|
|
|
types::type_(p)
|
|
|
|
}
|
|
|
|
|
|
|
|
pub(crate) fn pattern(p: &mut Parser) {
|
|
|
|
patterns::pattern(p)
|
|
|
|
}
|
|
|
|
|
2019-04-16 23:34:43 -05:00
|
|
|
pub(crate) fn stmt(p: &mut Parser, with_semi: bool) {
|
2019-04-18 14:49:56 -05:00
|
|
|
let with_semi = match with_semi {
|
|
|
|
true => expressions::StmtWithSemi::Yes,
|
|
|
|
false => expressions::StmtWithSemi::No,
|
|
|
|
};
|
|
|
|
|
2019-04-16 23:34:43 -05:00
|
|
|
expressions::stmt(p, with_semi)
|
|
|
|
}
|
|
|
|
|
2019-04-17 21:21:36 -05:00
|
|
|
pub(crate) fn item(p: &mut Parser) {
|
|
|
|
items::item_or_macro(p, true, items::ItemFlavor::Mod)
|
|
|
|
}
|
|
|
|
|
2019-02-21 04:27:45 -06:00
|
|
|
pub(crate) fn reparser(
|
2019-02-21 03:12:04 -06:00
|
|
|
node: SyntaxKind,
|
|
|
|
first_child: Option<SyntaxKind>,
|
|
|
|
parent: Option<SyntaxKind>,
|
|
|
|
) -> Option<fn(&mut Parser)> {
|
|
|
|
let res = match node {
|
2019-02-20 07:02:06 -06:00
|
|
|
BLOCK => expressions::block,
|
|
|
|
NAMED_FIELD_DEF_LIST => items::named_field_def_list,
|
|
|
|
NAMED_FIELD_LIST => items::named_field_list,
|
|
|
|
ENUM_VARIANT_LIST => items::enum_variant_list,
|
|
|
|
MATCH_ARM_LIST => items::match_arm_list,
|
|
|
|
USE_TREE_LIST => items::use_tree_list,
|
|
|
|
EXTERN_ITEM_LIST => items::extern_item_list,
|
2019-02-21 03:12:04 -06:00
|
|
|
TOKEN_TREE if first_child? == L_CURLY => items::token_tree,
|
|
|
|
ITEM_LIST => match parent? {
|
|
|
|
IMPL_BLOCK => items::impl_item_list,
|
|
|
|
TRAIT_DEF => items::trait_item_list,
|
|
|
|
MODULE => items::mod_item_list,
|
|
|
|
_ => return None,
|
|
|
|
},
|
2019-02-20 07:02:06 -06:00
|
|
|
_ => return None,
|
|
|
|
};
|
|
|
|
Some(res)
|
|
|
|
}
|
|
|
|
|
2018-08-07 08:32:09 -05:00
|
|
|
#[derive(Clone, Copy, PartialEq, Eq)]
|
2018-08-07 08:11:40 -05:00
|
|
|
enum BlockLike {
|
|
|
|
Block,
|
|
|
|
NotBlock,
|
|
|
|
}
|
|
|
|
|
2018-08-07 08:32:09 -05:00
|
|
|
impl BlockLike {
|
2018-10-15 16:44:23 -05:00
|
|
|
fn is_block(self) -> bool {
|
|
|
|
self == BlockLike::Block
|
|
|
|
}
|
2018-08-07 08:32:09 -05:00
|
|
|
}
|
|
|
|
|
2019-03-18 00:34:08 -05:00
|
|
|
fn opt_visibility(p: &mut Parser) -> bool {
|
2018-08-08 14:09:47 -05:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
_ => (),
|
2018-01-20 08:21:13 -06:00
|
|
|
}
|
2018-01-12 13:05:46 -06:00
|
|
|
}
|
2018-08-08 14:09:47 -05:00
|
|
|
m.complete(p, VISIBILITY);
|
2018-01-12 13:05:46 -06:00
|
|
|
}
|
2018-08-08 14:09:47 -05:00
|
|
|
// test crate_keyword_vis
|
|
|
|
// crate fn main() { }
|
2019-03-18 00:34:08 -05:00
|
|
|
// struct S { crate field: u32 }
|
|
|
|
// struct T(crate u32);
|
|
|
|
//
|
|
|
|
// test crate_keyword_path
|
|
|
|
// fn foo() { crate::foo(); }
|
|
|
|
CRATE_KW if p.nth(1) != COLONCOLON => {
|
2018-08-08 14:09:47 -05:00
|
|
|
let m = p.start();
|
|
|
|
p.bump();
|
|
|
|
m.complete(p, VISIBILITY);
|
|
|
|
}
|
2019-03-18 00:34:08 -05:00
|
|
|
_ => return false,
|
2018-01-20 08:21:13 -06:00
|
|
|
}
|
2019-03-18 00:34:08 -05:00
|
|
|
true
|
2018-01-01 09:58:46 -06:00
|
|
|
}
|
2018-08-23 17:19:38 -05:00
|
|
|
|
|
|
|
fn opt_alias(p: &mut Parser) {
|
2018-01-20 08:21:13 -06:00
|
|
|
if p.at(AS_KW) {
|
2018-08-23 17:19:38 -05:00
|
|
|
let m = p.start();
|
2018-01-20 08:21:13 -06:00
|
|
|
p.bump();
|
2019-03-04 07:38:54 -06:00
|
|
|
if !p.eat(UNDERSCORE) {
|
|
|
|
name(p);
|
|
|
|
}
|
2018-08-23 17:19:38 -05:00
|
|
|
m.complete(p, ALIAS);
|
2018-01-20 08:21:13 -06:00
|
|
|
}
|
2018-01-08 15:06:42 -06:00
|
|
|
}
|
|
|
|
|
2018-02-11 03:51:09 -06:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2018-08-23 18:14:10 -05:00
|
|
|
fn opt_fn_ret_type(p: &mut Parser) -> bool {
|
2018-02-11 03:51:09 -06:00
|
|
|
if p.at(THIN_ARROW) {
|
2018-08-28 13:11:17 -05:00
|
|
|
let m = p.start();
|
2018-02-11 03:51:09 -06:00
|
|
|
p.bump();
|
|
|
|
types::type_(p);
|
2018-08-28 13:11:17 -05:00
|
|
|
m.complete(p, RET_TYPE);
|
2018-07-31 15:13:08 -05:00
|
|
|
true
|
|
|
|
} else {
|
|
|
|
false
|
2018-02-11 03:51:09 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-31 05:35:48 -05:00
|
|
|
fn name_r(p: &mut Parser, recovery: TokenSet) {
|
2018-02-10 05:00:23 -06:00
|
|
|
if p.at(IDENT) {
|
|
|
|
let m = p.start();
|
|
|
|
p.bump();
|
|
|
|
m.complete(p, NAME);
|
|
|
|
} else {
|
2018-08-31 05:35:48 -05:00
|
|
|
p.err_recover("expected a name", recovery);
|
2018-02-10 05:00:23 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-31 05:35:48 -05:00
|
|
|
fn name(p: &mut Parser) {
|
2019-01-18 02:02:30 -06:00
|
|
|
name_r(p, TokenSet::empty())
|
2018-08-31 05:35:48 -05:00
|
|
|
}
|
|
|
|
|
2018-02-10 05:17:38 -06:00
|
|
|
fn name_ref(p: &mut Parser) {
|
|
|
|
if p.at(IDENT) {
|
|
|
|
let m = p.start();
|
|
|
|
p.bump();
|
|
|
|
m.complete(p, NAME_REF);
|
2019-03-28 11:15:18 -05:00
|
|
|
} else if p.at(SELF_KW) {
|
|
|
|
let m = p.start();
|
|
|
|
p.bump();
|
|
|
|
m.complete(p, SELF_KW);
|
2018-02-10 05:17:38 -06:00
|
|
|
} else {
|
2018-08-13 10:30:56 -05:00
|
|
|
p.err_and_bump("expected identifier");
|
2018-02-10 05:17:38 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-28 11:48:37 -06:00
|
|
|
fn error_block(p: &mut Parser, message: &str) {
|
2019-03-04 05:24:02 -06:00
|
|
|
assert!(p.at(L_CURLY));
|
|
|
|
let m = p.start();
|
|
|
|
p.error(message);
|
|
|
|
p.bump();
|
|
|
|
expressions::expr_block_contents(p);
|
|
|
|
p.eat(R_CURLY);
|
|
|
|
m.complete(p, ERROR);
|
2018-01-28 11:48:37 -06:00
|
|
|
}
|