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`](super::parser::Parser) to learn about API,
10 //! available to the grammar, and see docs for [`Event`](super::event::Event)
11 //! to learn how this actually manages to 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 test -p xtask` 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.
42 parser::{CompletedMarker, Marker, Parser},
43 SyntaxKind::{self, *},
47 pub(crate) mod entry {
50 pub(crate) mod prefix {
53 pub(crate) fn vis(p: &mut Parser) {
54 let _ = opt_visibility(p, false);
57 pub(crate) fn block(p: &mut Parser) {
58 expressions::block_expr(p);
61 pub(crate) fn stmt(p: &mut Parser) {
62 expressions::stmt(p, expressions::StmtWithSemi::No, true);
65 pub(crate) fn pat(p: &mut Parser) {
66 patterns::pattern_single(p);
69 pub(crate) fn ty(p: &mut Parser) {
72 pub(crate) fn expr(p: &mut Parser) {
73 let _ = expressions::expr(p);
75 pub(crate) fn path(p: &mut Parser) {
76 let _ = paths::type_path(p);
78 pub(crate) fn item(p: &mut Parser) {
79 items::item_or_macro(p, true);
81 // Parse a meta item , which excluded [], e.g : #[ MetaItem ]
82 pub(crate) fn meta_item(p: &mut Parser) {
90 pub(crate) fn source_file(p: &mut Parser) {
93 items::mod_contents(p, false);
94 m.complete(p, SOURCE_FILE);
97 pub(crate) fn macro_stmts(p: &mut Parser) {
106 expressions::stmt(p, expressions::StmtWithSemi::Optional, true);
109 m.complete(p, MACRO_STMTS);
112 pub(crate) fn macro_items(p: &mut Parser) {
114 items::mod_contents(p, false);
115 m.complete(p, MACRO_ITEMS);
120 pub(crate) mod entry_points {
123 pub(crate) fn stmt_optional_semi(p: &mut Parser) {
124 expressions::stmt(p, expressions::StmtWithSemi::Optional, false);
127 pub(crate) fn attr(p: &mut Parser) {
128 attributes::outer_attrs(p);
132 pub(crate) fn reparser(
134 first_child: Option<SyntaxKind>,
135 parent: Option<SyntaxKind>,
136 ) -> Option<fn(&mut Parser)> {
137 let res = match node {
138 BLOCK_EXPR => expressions::block_expr,
139 RECORD_FIELD_LIST => items::record_field_list,
140 RECORD_EXPR_FIELD_LIST => items::record_expr_field_list,
141 VARIANT_LIST => items::variant_list,
142 MATCH_ARM_LIST => items::match_arm_list,
143 USE_TREE_LIST => items::use_tree_list,
144 EXTERN_ITEM_LIST => items::extern_item_list,
145 TOKEN_TREE if first_child? == T!['{'] => items::token_tree,
146 ASSOC_ITEM_LIST => match parent? {
147 IMPL | TRAIT => items::assoc_item_list,
150 ITEM_LIST => items::item_list,
156 #[derive(Clone, Copy, PartialEq, Eq)]
163 fn is_block(self) -> bool {
164 self == BlockLike::Block
168 fn opt_visibility(p: &mut Parser, in_tuple_field: bool) -> bool {
175 // test crate_visibility
176 // pub(crate) struct S;
177 // pub(self) struct S;
178 // pub(super) struct S;
180 // test pub_parens_typepath
181 // struct B(pub (super::A));
182 // struct B(pub (crate::A,));
183 T![crate] | T![self] | T![super] | T![ident] if p.nth(2) != T![:] => {
184 // If we are in a tuple struct, then the parens following `pub`
185 // might be an tuple field, not part of the visibility. So in that
186 // case we don't want to consume an identifier.
188 // test pub_tuple_field
189 // struct MyStruct(pub (u32, u32));
190 if !(in_tuple_field && matches!(p.nth(1), T![ident])) {
196 // test crate_visibility_in
197 // pub(in super::A) struct S;
198 // pub(in crate) struct S;
208 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 if p.nth_at(1, T![::]) {
217 // test crate_keyword_path
218 // fn foo() { crate::foo(); }
223 m.complete(p, VISIBILITY);
230 fn opt_rename(p: &mut Parser) {
237 m.complete(p, RENAME);
241 fn abi(p: &mut Parser) {
242 assert!(p.at(T![extern]));
246 abi.complete(p, ABI);
249 fn opt_ret_type(p: &mut Parser) -> bool {
253 types::type_no_bounds(p);
254 m.complete(p, RET_TYPE);
261 fn name_r(p: &mut Parser, recovery: TokenSet) {
267 p.err_recover("expected a name", recovery);
271 fn name(p: &mut Parser) {
272 name_r(p, TokenSet::EMPTY);
275 fn name_ref(p: &mut Parser) {
279 m.complete(p, NAME_REF);
281 p.err_and_bump("expected identifier");
285 fn name_ref_or_index(p: &mut Parser) {
286 assert!(p.at(IDENT) || p.at(INT_NUMBER));
289 m.complete(p, NAME_REF);
292 fn lifetime(p: &mut Parser) {
293 assert!(p.at(LIFETIME_IDENT));
295 p.bump(LIFETIME_IDENT);
296 m.complete(p, LIFETIME);
299 fn error_block(p: &mut Parser, message: &str) {
300 assert!(p.at(T!['{']));
304 expressions::expr_block_contents(p);
306 m.complete(p, ERROR);