1 //! This is the actual "grammar" of the Rust language.
3 //! Each function in this module and its children corresponds
4 //! to a production of the formal grammar. Submodules roughly
5 //! correspond to different *areas* of the grammar. By convention,
6 //! each submodule starts with `use super::*` import and exports
7 //! "public" productions via `pub(super)`.
9 //! See docs for `Parser` to learn about API, available to the grammar,
10 //! and see docs for `Event` to learn how this actually manages to
11 //! produce parse trees.
13 //! Code in this module also contains inline tests, which start with
14 //! `// test name-of-the-test` comment and look like this:
17 //! // test function_with_zero_parameters
21 //! After adding a new inline-test, run `cargo xtask codegen` to
22 //! extract it as a standalone text-fixture into
23 //! `crates/syntax/test_data/parser/`, and run `cargo test` once to
24 //! create the "gold" value.
26 //! Coding convention: rules like `where_clause` always produce either a
27 //! node or an error, rules like `opt_where_clause` may produce nothing.
28 //! Non-opt rules typically start with `assert!(p.at(FIRST_TOKEN))`, the
29 //! caller is responsible for branching on the first token.
41 parser::{CompletedMarker, Marker, Parser},
42 SyntaxKind::{self, *},
46 pub(crate) fn root(p: &mut Parser) {
49 items::mod_contents(p, false);
50 m.complete(p, SOURCE_FILE);
53 /// Various pieces of syntax that can be parsed by macros by example
54 pub(crate) mod fragments {
57 pub(crate) use super::{
58 expressions::block_expr, paths::type_path as path, patterns::pattern_single, types::type_,
61 pub(crate) fn expr(p: &mut Parser) {
62 let _ = expressions::expr_with_attrs(p);
65 pub(crate) fn stmt(p: &mut Parser) {
66 expressions::stmt(p, expressions::StmtWithSemi::No)
69 pub(crate) fn opt_visibility(p: &mut Parser) {
70 let _ = super::opt_visibility(p);
73 // Parse a meta item , which excluded [], e.g : #[ MetaItem ]
74 pub(crate) fn meta_item(p: &mut Parser) {
75 fn is_delimiter(p: &mut Parser) -> bool {
76 matches!(p.current(), T!['{'] | T!['('] | T!['['])
90 // https://doc.rust-lang.org/reference/attributes.html
91 // https://doc.rust-lang.org/reference/paths.html#simple-paths
92 // The start of an meta must be a simple path
94 IDENT | T![::] | T![super] | T![self] | T![crate] => p.bump_any(),
98 c if c.is_literal() => p.bump_any(),
99 T![true] | T![false] => p.bump_any(),
109 m.complete(p, TOKEN_TREE);
112 pub(crate) fn item(p: &mut Parser) {
113 items::item_or_macro(p, true)
116 pub(crate) fn macro_items(p: &mut Parser) {
118 items::mod_contents(p, false);
119 m.complete(p, MACRO_ITEMS);
122 pub(crate) fn macro_stmts(p: &mut Parser) {
131 expressions::stmt(p, expressions::StmtWithSemi::Optional);
134 m.complete(p, MACRO_STMTS);
137 pub(crate) fn attr(p: &mut Parser) {
138 attributes::outer_attrs(p)
142 pub(crate) fn reparser(
144 first_child: Option<SyntaxKind>,
145 parent: Option<SyntaxKind>,
146 ) -> Option<fn(&mut Parser)> {
147 let res = match node {
148 BLOCK_EXPR => expressions::block_expr,
149 RECORD_FIELD_LIST => items::record_field_list,
150 RECORD_EXPR_FIELD_LIST => items::record_expr_field_list,
151 VARIANT_LIST => items::variant_list,
152 MATCH_ARM_LIST => items::match_arm_list,
153 USE_TREE_LIST => items::use_tree_list,
154 EXTERN_ITEM_LIST => items::extern_item_list,
155 TOKEN_TREE if first_child? == T!['{'] => items::token_tree,
156 ASSOC_ITEM_LIST => match parent? {
157 IMPL => items::assoc_item_list,
158 TRAIT => items::assoc_item_list,
161 ITEM_LIST => items::item_list,
167 #[derive(Clone, Copy, PartialEq, Eq)]
174 fn is_block(self) -> bool {
175 self == BlockLike::Block
179 fn opt_visibility(p: &mut Parser) -> bool {
186 // test crate_visibility
187 // pub(crate) struct S;
188 // pub(self) struct S;
189 // pub(self) struct S;
190 // pub(self) struct S;
192 // test pub_parens_typepath
193 // struct B(pub (super::A));
194 // struct B(pub (crate::A,));
195 T![crate] | T![self] | T![super] if p.nth(2) != T![:] => {
209 m.complete(p, VISIBILITY);
211 // test crate_keyword_vis
212 // crate fn main() { }
213 // struct S { crate field: u32 }
214 // struct T(crate u32);
216 // test crate_keyword_path
217 // fn foo() { crate::foo(); }
218 T![crate] if !p.nth_at(1, T![::]) => {
221 m.complete(p, VISIBILITY);
228 fn opt_rename(p: &mut Parser) {
235 m.complete(p, RENAME);
239 fn abi(p: &mut Parser) {
240 assert!(p.at(T![extern]));
244 abi.complete(p, ABI);
247 fn opt_ret_type(p: &mut Parser) -> bool {
251 types::type_no_bounds(p);
252 m.complete(p, RET_TYPE);
259 fn name_r(p: &mut Parser, recovery: TokenSet) {
265 p.err_recover("expected a name", recovery);
269 fn name(p: &mut Parser) {
270 name_r(p, TokenSet::EMPTY)
273 fn name_ref(p: &mut Parser) {
277 m.complete(p, NAME_REF);
279 p.err_and_bump("expected identifier");
283 fn name_ref_or_index(p: &mut Parser) {
284 assert!(p.at(IDENT) || p.at(INT_NUMBER));
287 m.complete(p, NAME_REF);
290 fn lifetime(p: &mut Parser) {
291 assert!(p.at(LIFETIME_IDENT));
293 p.bump(LIFETIME_IDENT);
294 m.complete(p, LIFETIME);
297 fn error_block(p: &mut Parser, message: &str) {
298 assert!(p.at(T!['{']));
302 expressions::expr_block_contents(p);
304 m.complete(p, ERROR);