rust/crates/parser/src/grammar.rs

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

386 lines
10 KiB
Rust
Raw Normal View History

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 formal grammar. Submodules roughly
2018-02-11 08:58:22 -06:00
//! 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`](super::parser::Parser) to learn about API,
//! available to the grammar, and see docs for [`Event`](super::event::Event)
//! to learn how this actually manages to produce parse trees.
2018-02-11 08:58:22 -06:00
//!
//! 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 test -p xtask` to
//! extract it as a standalone text-fixture into
2020-08-12 11:26:51 -05:00
//! `crates/syntax/test_data/parser/`, 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.
2021-05-22 09:20:22 -05:00
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;
2021-09-18 07:54:55 -05:00
mod generic_args;
mod generic_params;
2018-07-30 06:08:06 -05:00
mod types;
2018-01-01 09:58:46 -06:00
use crate::{
parser::{CompletedMarker, Marker, Parser},
SyntaxKind::{self, *},
2021-09-06 10:42:07 -05:00
TokenSet, T,
};
2018-07-29 07:16:07 -05:00
2021-12-27 06:17:48 -06:00
pub(crate) mod entry {
use super::*;
pub(crate) mod prefix {
use super::*;
2022-07-20 08:02:08 -05:00
pub(crate) fn vis(p: &mut Parser<'_>) {
opt_visibility(p, false);
2021-12-27 06:17:48 -06:00
}
2022-07-20 08:02:08 -05:00
pub(crate) fn block(p: &mut Parser<'_>) {
expressions::block_expr(p);
}
2021-12-27 06:54:00 -06:00
2022-07-20 08:02:08 -05:00
pub(crate) fn stmt(p: &mut Parser<'_>) {
2021-12-29 10:18:34 -06:00
expressions::stmt(p, expressions::Semicolon::Forbidden);
2021-12-27 06:54:00 -06:00
}
2021-12-27 07:06:02 -06:00
2022-07-20 08:02:08 -05:00
pub(crate) fn pat(p: &mut Parser<'_>) {
2021-12-27 07:06:02 -06:00
patterns::pattern_single(p);
}
2021-12-27 07:08:35 -06:00
pub(crate) fn pat_top(p: &mut Parser<'_>) {
patterns::pattern_top(p);
}
2022-07-20 08:02:08 -05:00
pub(crate) fn ty(p: &mut Parser<'_>) {
2021-12-27 07:08:35 -06:00
types::type_(p);
}
2022-07-20 08:02:08 -05:00
pub(crate) fn expr(p: &mut Parser<'_>) {
expressions::expr(p);
2021-12-27 07:17:29 -06:00
}
2022-07-20 08:02:08 -05:00
pub(crate) fn path(p: &mut Parser<'_>) {
paths::type_path(p);
2021-12-27 07:23:07 -06:00
}
2022-07-20 08:02:08 -05:00
pub(crate) fn item(p: &mut Parser<'_>) {
2021-12-27 07:28:54 -06:00
items::item_or_macro(p, true);
}
// Parse a meta item , which excluded [], e.g : #[ MetaItem ]
2022-07-20 08:02:08 -05:00
pub(crate) fn meta_item(p: &mut Parser<'_>) {
2021-12-27 07:28:54 -06:00
attributes::meta(p);
}
2021-12-27 06:17:48 -06:00
}
2021-12-27 08:54:51 -06:00
pub(crate) mod top {
use super::*;
2022-07-20 08:02:08 -05:00
pub(crate) fn source_file(p: &mut Parser<'_>) {
2021-12-27 08:54:51 -06:00
let m = p.start();
p.eat(SHEBANG);
items::mod_contents(p, false);
m.complete(p, SOURCE_FILE);
}
2022-07-20 08:02:08 -05:00
pub(crate) fn macro_stmts(p: &mut Parser<'_>) {
2021-12-27 08:54:51 -06:00
let m = p.start();
2019-04-19 06:33:29 -05:00
2021-12-27 08:54:51 -06:00
while !p.at(EOF) {
2021-12-29 10:18:34 -06:00
expressions::stmt(p, expressions::Semicolon::Optional);
2019-04-25 10:12:57 -05:00
}
2019-09-02 09:37:48 -05:00
2021-12-27 08:54:51 -06:00
m.complete(p, MACRO_STMTS);
}
2022-07-20 08:02:08 -05:00
pub(crate) fn macro_items(p: &mut Parser<'_>) {
2021-12-27 08:54:51 -06:00
let m = p.start();
items::mod_contents(p, false);
m.complete(p, MACRO_ITEMS);
2019-04-19 06:33:29 -05:00
}
2022-01-02 08:32:15 -06:00
2022-07-20 08:02:08 -05:00
pub(crate) fn pattern(p: &mut Parser<'_>) {
2022-01-02 08:32:15 -06:00
let m = p.start();
2022-01-17 09:52:53 -06:00
patterns::pattern_top(p);
2022-01-02 08:32:15 -06:00
if p.at(EOF) {
m.abandon(p);
return;
}
while !p.at(EOF) {
p.bump_any();
}
m.complete(p, ERROR);
}
2022-01-02 08:45:18 -06:00
2022-07-20 08:02:08 -05:00
pub(crate) fn type_(p: &mut Parser<'_>) {
2022-01-02 08:45:18 -06:00
let m = p.start();
types::type_(p);
if p.at(EOF) {
m.abandon(p);
return;
}
while !p.at(EOF) {
p.bump_any();
}
m.complete(p, ERROR);
}
2022-01-02 08:52:05 -06:00
2022-07-20 08:02:08 -05:00
pub(crate) fn expr(p: &mut Parser<'_>) {
2022-01-02 08:52:05 -06:00
let m = p.start();
expressions::expr(p);
if p.at(EOF) {
m.abandon(p);
return;
}
while !p.at(EOF) {
p.bump_any();
}
m.complete(p, ERROR);
}
2022-01-02 09:41:32 -06:00
2022-07-20 08:02:08 -05:00
pub(crate) fn meta_item(p: &mut Parser<'_>) {
2022-01-02 09:41:32 -06:00
let m = p.start();
attributes::meta(p);
if p.at(EOF) {
m.abandon(p);
return;
}
while !p.at(EOF) {
p.bump_any();
}
m.complete(p, ERROR);
}
2021-12-27 08:54:51 -06:00
}
}
2019-04-19 06:33:29 -05:00
2019-02-21 04:27:45 -06:00
pub(crate) fn reparser(
node: SyntaxKind,
first_child: Option<SyntaxKind>,
parent: Option<SyntaxKind>,
2022-07-20 08:02:08 -05:00
) -> Option<fn(&mut Parser<'_>)> {
let res = match node {
2020-05-02 07:34:39 -05:00
BLOCK_EXPR => expressions::block_expr,
2020-08-13 10:58:35 -05:00
RECORD_FIELD_LIST => items::record_field_list,
RECORD_EXPR_FIELD_LIST => items::record_expr_field_list,
VARIANT_LIST => items::variant_list,
2019-02-20 07:02:06 -06:00
MATCH_ARM_LIST => items::match_arm_list,
USE_TREE_LIST => items::use_tree_list,
EXTERN_ITEM_LIST => items::extern_item_list,
2019-05-15 07:35:47 -05:00
TOKEN_TREE if first_child? == T!['{'] => items::token_tree,
2020-07-30 04:48:19 -05:00
ASSOC_ITEM_LIST => match parent? {
2021-10-03 07:45:08 -05:00
IMPL | TRAIT => items::assoc_item_list,
_ => return None,
},
2020-08-13 10:58:35 -05:00
ITEM_LIST => items::item_list,
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 {
fn is_block(self) -> bool {
self == BlockLike::Block
}
2023-03-06 18:24:05 -06:00
fn is_blocklike(kind: SyntaxKind) -> bool {
matches!(kind, BLOCK_EXPR | IF_EXPR | WHILE_EXPR | FOR_EXPR | LOOP_EXPR | MATCH_EXPR)
}
2018-08-07 08:32:09 -05:00
}
const VISIBILITY_FIRST: TokenSet = TokenSet::new(&[T![pub], T![crate]]);
2022-07-20 08:02:08 -05:00
fn opt_visibility(p: &mut Parser<'_>, in_tuple_field: bool) -> bool {
2018-08-08 14:09:47 -05:00
match p.current() {
2019-05-15 07:35:47 -05:00
T![pub] => {
2018-08-08 14:09:47 -05:00
let m = p.start();
p.bump(T![pub]);
2019-05-15 07:35:47 -05:00
if p.at(T!['(']) {
2018-08-08 14:09:47 -05:00
match p.nth(1) {
// test crate_visibility
// pub(crate) struct S;
// pub(self) struct S;
// pub(super) struct S;
// test_err crate_visibility_empty_recover
// pub() struct S;
// test pub_parens_typepath
// struct B(pub (super::A));
// struct B(pub (crate::A,));
T![crate] | T![self] | T![super] | T![ident] | T![')'] if p.nth(2) != T![:] => {
// If we are in a tuple struct, then the parens following `pub`
// might be an tuple field, not part of the visibility. So in that
// case we don't want to consume an identifier.
// test pub_tuple_field
// struct MyStruct(pub (u32, u32));
// struct MyStruct(pub (u32));
// struct MyStruct(pub ());
if !(in_tuple_field && matches!(p.nth(1), T![ident] | T![')'])) {
p.bump(T!['(']);
paths::use_path(p);
p.expect(T![')']);
}
2018-08-08 14:09:47 -05:00
}
// test crate_visibility_in
// pub(in super::A) struct S;
// pub(in crate) struct S;
2019-05-15 07:35:47 -05:00
T![in] => {
2021-09-17 15:27:26 -05:00
p.bump(T!['(']);
p.bump(T![in]);
2018-08-08 14:09:47 -05:00
paths::use_path(p);
2019-05-15 07:35:47 -05:00
p.expect(T![')']);
2018-08-08 14:09:47 -05:00
}
_ => {}
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);
2021-09-17 16:14:20 -05:00
true
2018-01-12 13:05:46 -06:00
}
2018-08-08 14:09:47 -05:00
// test crate_keyword_vis
// crate fn main() { }
// struct S { crate field: u32 }
// struct T(crate u32);
T![crate] => {
if p.nth_at(1, T![::]) {
// test crate_keyword_path
// fn foo() { crate::foo(); }
return false;
}
2018-08-08 14:09:47 -05:00
let m = p.start();
2019-09-19 14:51:46 -05:00
p.bump(T![crate]);
2018-08-08 14:09:47 -05:00
m.complete(p, VISIBILITY);
2021-09-17 16:14:20 -05:00
true
2018-08-08 14:09:47 -05:00
}
2021-09-17 16:14:20 -05:00
_ => false,
2018-01-20 08:21:13 -06:00
}
2018-01-01 09:58:46 -06:00
}
2018-08-23 17:19:38 -05:00
2022-07-20 08:02:08 -05:00
fn opt_rename(p: &mut Parser<'_>) {
2019-05-15 07:35:47 -05:00
if p.at(T![as]) {
2018-08-23 17:19:38 -05:00
let m = p.start();
2019-09-19 14:51:46 -05:00
p.bump(T![as]);
2019-05-15 07:35:47 -05:00
if !p.eat(T![_]) {
name(p);
}
2020-07-30 04:58:41 -05:00
m.complete(p, RENAME);
2018-01-20 08:21:13 -06:00
}
2018-01-08 15:06:42 -06:00
}
2022-07-20 08:02:08 -05:00
fn abi(p: &mut Parser<'_>) {
2019-05-15 07:35:47 -05:00
assert!(p.at(T![extern]));
2018-02-11 03:51:09 -06:00
let abi = p.start();
2019-09-19 14:51:46 -05:00
p.bump(T![extern]);
p.eat(STRING);
2018-02-11 03:51:09 -06:00
abi.complete(p, ABI);
}
2022-07-20 08:02:08 -05:00
fn opt_ret_type(p: &mut Parser<'_>) -> bool {
2019-05-15 07:35:47 -05:00
if p.at(T![->]) {
2018-08-28 13:11:17 -05:00
let m = p.start();
p.bump(T![->]);
types::type_no_bounds(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
}
}
2022-07-20 08:02:08 -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();
2019-09-19 14:51:46 -05:00
p.bump(IDENT);
2018-02-10 05:00:23 -06:00
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
}
}
2022-07-20 08:02:08 -05:00
fn name(p: &mut Parser<'_>) {
name_r(p, TokenSet::EMPTY);
2018-08-31 05:35:48 -05:00
}
2022-07-20 08:02:08 -05:00
fn name_ref(p: &mut Parser<'_>) {
2019-08-09 05:16:47 -05:00
if p.at(IDENT) {
2018-02-10 05:17:38 -06:00
let m = p.start();
2019-09-19 14:51:46 -05:00
p.bump(IDENT);
2018-02-10 05:17:38 -06:00
m.complete(p, NAME_REF);
} else {
2018-08-13 10:30:56 -05:00
p.err_and_bump("expected identifier");
2018-02-10 05:17:38 -06:00
}
}
2022-07-20 08:02:08 -05:00
fn name_ref_or_index(p: &mut Parser<'_>) {
assert!(p.at(IDENT) || p.at(INT_NUMBER));
2020-04-11 16:08:05 -05:00
let m = p.start();
p.bump_any();
2020-04-11 16:08:05 -05:00
m.complete(p, NAME_REF);
2019-08-09 05:16:47 -05:00
}
2022-07-20 08:02:08 -05:00
fn lifetime(p: &mut Parser<'_>) {
2020-12-15 12:23:51 -06:00
assert!(p.at(LIFETIME_IDENT));
let m = p.start();
p.bump(LIFETIME_IDENT);
m.complete(p, LIFETIME);
}
2022-07-20 08:02:08 -05:00
fn error_block(p: &mut Parser<'_>, message: &str) {
2019-05-15 07:35:47 -05:00
assert!(p.at(T!['{']));
let m = p.start();
p.error(message);
2019-09-19 14:51:46 -05:00
p.bump(T!['{']);
expressions::expr_block_contents(p);
2019-05-15 07:35:47 -05:00
p.eat(T!['}']);
m.complete(p, ERROR);
2018-01-28 11:48:37 -06:00
}
/// The `parser` passed this is required to at least consume one token if it returns `true`.
/// If the `parser` returns false, parsing will stop.
fn delimited(
p: &mut Parser<'_>,
bra: SyntaxKind,
ket: SyntaxKind,
delim: SyntaxKind,
first_set: TokenSet,
mut parser: impl FnMut(&mut Parser<'_>) -> bool,
) {
p.bump(bra);
while !p.at(ket) && !p.at(EOF) {
if !parser(p) {
break;
}
if !p.at(delim) {
if p.at_ts(first_set) {
p.error(format!("expected {:?}", delim));
} else {
break;
}
} else {
p.bump(delim);
}
}
p.expect(ket);
}