diff options
author | Dmitry <[email protected]> | 2020-08-09 14:35:51 +0100 |
---|---|---|
committer | Dmitry <[email protected]> | 2020-08-09 14:39:32 +0100 |
commit | 8068302fefc75440b823f4bf1731a5f347d7c767 (patch) | |
tree | 251b967182e79bc82a58c2fb208c688f6152df1f /xtask/src/ast_src.rs | |
parent | 1a43a0f63e0008787225abb6fb2baef97b6a39e0 (diff) | |
parent | 8a57afe5a4bfab40072a83f7dc4ca560bf860919 (diff) |
Merge remote-tracking branch 'origin/master'
Diffstat (limited to 'xtask/src/ast_src.rs')
-rw-r--r-- | xtask/src/ast_src.rs | 2102 |
1 files changed, 60 insertions, 2042 deletions
diff --git a/xtask/src/ast_src.rs b/xtask/src/ast_src.rs index 392648d71..adc191254 100644 --- a/xtask/src/ast_src.rs +++ b/xtask/src/ast_src.rs | |||
@@ -93,19 +93,19 @@ pub(crate) const KINDS_SRC: KindsSrc = KindsSrc { | |||
93 | ], | 93 | ], |
94 | nodes: &[ | 94 | nodes: &[ |
95 | "SOURCE_FILE", | 95 | "SOURCE_FILE", |
96 | "STRUCT_DEF", | 96 | "STRUCT", |
97 | "UNION_DEF", | 97 | "UNION", |
98 | "ENUM_DEF", | 98 | "ENUM", |
99 | "FN_DEF", | 99 | "FN", |
100 | "RET_TYPE", | 100 | "RET_TYPE", |
101 | "EXTERN_CRATE_ITEM", | 101 | "EXTERN_CRATE", |
102 | "MODULE", | 102 | "MODULE", |
103 | "USE_ITEM", | 103 | "USE", |
104 | "STATIC_DEF", | 104 | "STATIC", |
105 | "CONST_DEF", | 105 | "CONST", |
106 | "TRAIT_DEF", | 106 | "TRAIT", |
107 | "IMPL_DEF", | 107 | "IMPL", |
108 | "TYPE_ALIAS_DEF", | 108 | "TYPE_ALIAS", |
109 | "MACRO_CALL", | 109 | "MACRO_CALL", |
110 | "TOKEN_TREE", | 110 | "TOKEN_TREE", |
111 | "MACRO_DEF", | 111 | "MACRO_DEF", |
@@ -113,12 +113,12 @@ pub(crate) const KINDS_SRC: KindsSrc = KindsSrc { | |||
113 | "TUPLE_TYPE", | 113 | "TUPLE_TYPE", |
114 | "NEVER_TYPE", | 114 | "NEVER_TYPE", |
115 | "PATH_TYPE", | 115 | "PATH_TYPE", |
116 | "POINTER_TYPE", | 116 | "PTR_TYPE", |
117 | "ARRAY_TYPE", | 117 | "ARRAY_TYPE", |
118 | "SLICE_TYPE", | 118 | "SLICE_TYPE", |
119 | "REFERENCE_TYPE", | 119 | "REF_TYPE", |
120 | "PLACEHOLDER_TYPE", | 120 | "INFER_TYPE", |
121 | "FN_POINTER_TYPE", | 121 | "FN_PTR_TYPE", |
122 | "FOR_TYPE", | 122 | "FOR_TYPE", |
123 | "IMPL_TRAIT_TYPE", | 123 | "IMPL_TRAIT_TYPE", |
124 | "DYN_TRAIT_TYPE", | 124 | "DYN_TRAIT_TYPE", |
@@ -126,13 +126,13 @@ pub(crate) const KINDS_SRC: KindsSrc = KindsSrc { | |||
126 | "PAREN_PAT", | 126 | "PAREN_PAT", |
127 | "REF_PAT", | 127 | "REF_PAT", |
128 | "BOX_PAT", | 128 | "BOX_PAT", |
129 | "BIND_PAT", | 129 | "IDENT_PAT", |
130 | "PLACEHOLDER_PAT", | 130 | "WILDCARD_PAT", |
131 | "DOT_DOT_PAT", | 131 | "REST_PAT", |
132 | "PATH_PAT", | 132 | "PATH_PAT", |
133 | "RECORD_PAT", | 133 | "RECORD_PAT", |
134 | "RECORD_FIELD_PAT_LIST", | 134 | "RECORD_PAT_FIELD_LIST", |
135 | "RECORD_FIELD_PAT", | 135 | "RECORD_PAT_FIELD", |
136 | "TUPLE_STRUCT_PAT", | 136 | "TUPLE_STRUCT_PAT", |
137 | "TUPLE_PAT", | 137 | "TUPLE_PAT", |
138 | "SLICE_PAT", | 138 | "SLICE_PAT", |
@@ -144,7 +144,7 @@ pub(crate) const KINDS_SRC: KindsSrc = KindsSrc { | |||
144 | "ARRAY_EXPR", | 144 | "ARRAY_EXPR", |
145 | "PAREN_EXPR", | 145 | "PAREN_EXPR", |
146 | "PATH_EXPR", | 146 | "PATH_EXPR", |
147 | "LAMBDA_EXPR", | 147 | "CLOSURE_EXPR", |
148 | "IF_EXPR", | 148 | "IF_EXPR", |
149 | "WHILE_EXPR", | 149 | "WHILE_EXPR", |
150 | "CONDITION", | 150 | "CONDITION", |
@@ -159,9 +159,9 @@ pub(crate) const KINDS_SRC: KindsSrc = KindsSrc { | |||
159 | "MATCH_ARM_LIST", | 159 | "MATCH_ARM_LIST", |
160 | "MATCH_ARM", | 160 | "MATCH_ARM", |
161 | "MATCH_GUARD", | 161 | "MATCH_GUARD", |
162 | "RECORD_LIT", | 162 | "RECORD_EXPR", |
163 | "RECORD_FIELD_LIST", | 163 | "RECORD_EXPR_FIELD_LIST", |
164 | "RECORD_FIELD", | 164 | "RECORD_EXPR_FIELD", |
165 | "EFFECT_EXPR", | 165 | "EFFECT_EXPR", |
166 | "BOX_EXPR", | 166 | "BOX_EXPR", |
167 | // postfix | 167 | // postfix |
@@ -179,13 +179,14 @@ pub(crate) const KINDS_SRC: KindsSrc = KindsSrc { | |||
179 | "BIN_EXPR", | 179 | "BIN_EXPR", |
180 | "EXTERN_BLOCK", | 180 | "EXTERN_BLOCK", |
181 | "EXTERN_ITEM_LIST", | 181 | "EXTERN_ITEM_LIST", |
182 | "ENUM_VARIANT", | 182 | "VARIANT", |
183 | "RECORD_FIELD_DEF_LIST", | 183 | "RECORD_FIELD_LIST", |
184 | "RECORD_FIELD_DEF", | 184 | "RECORD_FIELD", |
185 | "TUPLE_FIELD_DEF_LIST", | 185 | "TUPLE_FIELD_LIST", |
186 | "TUPLE_FIELD_DEF", | 186 | "TUPLE_FIELD", |
187 | "ENUM_VARIANT_LIST", | 187 | "VARIANT_LIST", |
188 | "ITEM_LIST", | 188 | "ITEM_LIST", |
189 | "ASSOC_ITEM_LIST", | ||
189 | "ATTR", | 190 | "ATTR", |
190 | "META_ITEM", // not an item actually | 191 | "META_ITEM", // not an item actually |
191 | "USE_TREE", | 192 | "USE_TREE", |
@@ -193,7 +194,7 @@ pub(crate) const KINDS_SRC: KindsSrc = KindsSrc { | |||
193 | "PATH", | 194 | "PATH", |
194 | "PATH_SEGMENT", | 195 | "PATH_SEGMENT", |
195 | "LITERAL", | 196 | "LITERAL", |
196 | "ALIAS", | 197 | "RENAME", |
197 | "VISIBILITY", | 198 | "VISIBILITY", |
198 | "WHERE_CLAUSE", | 199 | "WHERE_CLAUSE", |
199 | "WHERE_PRED", | 200 | "WHERE_PRED", |
@@ -202,11 +203,12 @@ pub(crate) const KINDS_SRC: KindsSrc = KindsSrc { | |||
202 | "NAME_REF", | 203 | "NAME_REF", |
203 | "LET_STMT", | 204 | "LET_STMT", |
204 | "EXPR_STMT", | 205 | "EXPR_STMT", |
205 | "TYPE_PARAM_LIST", | 206 | "GENERIC_PARAM_LIST", |
207 | "GENERIC_PARAM", | ||
206 | "LIFETIME_PARAM", | 208 | "LIFETIME_PARAM", |
207 | "TYPE_PARAM", | 209 | "TYPE_PARAM", |
208 | "CONST_PARAM", | 210 | "CONST_PARAM", |
209 | "TYPE_ARG_LIST", | 211 | "GENERIC_ARG_LIST", |
210 | "LIFETIME_ARG", | 212 | "LIFETIME_ARG", |
211 | "TYPE_ARG", | 213 | "TYPE_ARG", |
212 | "ASSOC_TYPE_ARG", | 214 | "ASSOC_TYPE_ARG", |
@@ -223,2021 +225,37 @@ pub(crate) const KINDS_SRC: KindsSrc = KindsSrc { | |||
223 | ], | 225 | ], |
224 | }; | 226 | }; |
225 | 227 | ||
226 | pub(crate) struct AstSrc<'a> { | 228 | #[derive(Default, Debug)] |
227 | pub(crate) tokens: &'a [&'a str], | 229 | pub(crate) struct AstSrc { |
228 | pub(crate) nodes: &'a [AstNodeSrc<'a>], | 230 | pub(crate) tokens: Vec<String>, |
229 | pub(crate) enums: &'a [AstEnumSrc<'a>], | 231 | pub(crate) nodes: Vec<AstNodeSrc>, |
230 | } | 232 | pub(crate) enums: Vec<AstEnumSrc>, |
231 | |||
232 | pub(crate) struct AstNodeSrc<'a> { | ||
233 | pub(crate) doc: &'a [&'a str], | ||
234 | pub(crate) name: &'a str, | ||
235 | pub(crate) traits: &'a [&'a str], | ||
236 | pub(crate) fields: &'a [Field<'a>], | ||
237 | } | ||
238 | |||
239 | pub(crate) enum Field<'a> { | ||
240 | Token(&'a str), | ||
241 | Node { name: &'a str, src: FieldSrc<'a> }, | ||
242 | } | ||
243 | |||
244 | pub(crate) enum FieldSrc<'a> { | ||
245 | Shorthand, | ||
246 | Optional(&'a str), | ||
247 | Many(&'a str), | ||
248 | } | 233 | } |
249 | 234 | ||
250 | pub(crate) struct AstEnumSrc<'a> { | 235 | #[derive(Debug)] |
251 | pub(crate) doc: &'a [&'a str], | 236 | pub(crate) struct AstNodeSrc { |
252 | pub(crate) name: &'a str, | 237 | pub(crate) doc: Vec<String>, |
253 | pub(crate) traits: &'a [&'a str], | 238 | pub(crate) name: String, |
254 | pub(crate) variants: &'a [&'a str], | 239 | pub(crate) traits: Vec<String>, |
240 | pub(crate) fields: Vec<Field>, | ||
255 | } | 241 | } |
256 | 242 | ||
257 | macro_rules! ast_nodes { | 243 | #[derive(Debug, Eq, PartialEq)] |
258 | ($( | 244 | pub(crate) enum Field { |
259 | $(#[doc = $doc:expr])+ | 245 | Token(String), |
260 | struct $name:ident$(: $($trait:ident),*)? { | 246 | Node { name: String, ty: String, cardinality: Cardinality }, |
261 | $($field_name:ident $(![$token:tt])? $(: $ty:tt)?),*$(,)? | ||
262 | } | ||
263 | )*) => { | ||
264 | [$( | ||
265 | AstNodeSrc { | ||
266 | doc: &[$($doc),*], | ||
267 | name: stringify!($name), | ||
268 | traits: &[$($(stringify!($trait)),*)?], | ||
269 | fields: &[ | ||
270 | $(field!($(T![$token])? $field_name $($ty)?)),* | ||
271 | ], | ||
272 | |||
273 | } | ||
274 | ),*] | ||
275 | }; | ||
276 | } | 247 | } |
277 | 248 | ||
278 | macro_rules! field { | 249 | #[derive(Debug, Eq, PartialEq)] |
279 | (T![$token:tt] T) => { | 250 | pub(crate) enum Cardinality { |
280 | Field::Token(stringify!($token)) | 251 | Optional, |
281 | }; | 252 | Many, |
282 | ($field_name:ident) => { | ||
283 | Field::Node { name: stringify!($field_name), src: FieldSrc::Shorthand } | ||
284 | }; | ||
285 | ($field_name:ident [$ty:ident]) => { | ||
286 | Field::Node { name: stringify!($field_name), src: FieldSrc::Many(stringify!($ty)) } | ||
287 | }; | ||
288 | ($field_name:ident $ty:ident) => { | ||
289 | Field::Node { name: stringify!($field_name), src: FieldSrc::Optional(stringify!($ty)) } | ||
290 | }; | ||
291 | } | 253 | } |
292 | 254 | ||
293 | macro_rules! ast_enums { | 255 | #[derive(Debug)] |
294 | ($( | 256 | pub(crate) struct AstEnumSrc { |
295 | $(#[doc = $doc:expr])+ | 257 | pub(crate) doc: Vec<String>, |
296 | enum $name:ident $(: $($trait:ident),*)? { | 258 | pub(crate) name: String, |
297 | $($variant:ident),*$(,)? | 259 | pub(crate) traits: Vec<String>, |
298 | } | 260 | pub(crate) variants: Vec<String>, |
299 | )*) => { | ||
300 | [$( | ||
301 | AstEnumSrc { | ||
302 | doc: &[$($doc),*], | ||
303 | name: stringify!($name), | ||
304 | traits: &[$($(stringify!($trait)),*)?], | ||
305 | variants: &[$(stringify!($variant)),*], | ||
306 | } | ||
307 | ),*] | ||
308 | }; | ||
309 | } | 261 | } |
310 | |||
311 | pub(crate) const AST_SRC: AstSrc = AstSrc { | ||
312 | tokens: &["Whitespace", "Comment", "String", "RawString"], | ||
313 | nodes: &ast_nodes! { | ||
314 | /// The entire Rust source file. Includes all top-level inner attributes and module items. | ||
315 | /// | ||
316 | /// [Reference](https://doc.rust-lang.org/reference/crates-and-source-files.html) | ||
317 | struct SourceFile: ModuleItemOwner, AttrsOwner, DocCommentsOwner { | ||
318 | modules: [Module], | ||
319 | } | ||
320 | |||
321 | /// Function definition either with body or not. | ||
322 | /// Includes all of its attributes and doc comments. | ||
323 | /// | ||
324 | /// ``` | ||
325 | /// ❰ | ||
326 | /// /// Docs | ||
327 | /// #[attr] | ||
328 | /// pub extern "C" fn foo<T>(#[attr] Patern {p}: Pattern) -> u32 | ||
329 | /// where | ||
330 | /// T: Debug | ||
331 | /// { | ||
332 | /// 42 | ||
333 | /// } | ||
334 | /// ❱ | ||
335 | /// | ||
336 | /// extern "C" { | ||
337 | /// ❰ fn fn_decl(also_variadic_ffi: u32, ...) -> u32; ❱ | ||
338 | /// } | ||
339 | /// ``` | ||
340 | /// | ||
341 | /// - [Reference](https://doc.rust-lang.org/reference/items/functions.html) | ||
342 | /// - [Nomicon](https://doc.rust-lang.org/nomicon/ffi.html#variadic-functions) | ||
343 | struct FnDef: VisibilityOwner, NameOwner, TypeParamsOwner, DocCommentsOwner, AttrsOwner { | ||
344 | Abi, | ||
345 | T![const], | ||
346 | T![default], | ||
347 | T![async], | ||
348 | T![unsafe], | ||
349 | T![fn], | ||
350 | ParamList, | ||
351 | RetType, | ||
352 | body: BlockExpr, | ||
353 | T![;] | ||
354 | } | ||
355 | |||
356 | /// Return type annotation. | ||
357 | /// | ||
358 | /// ``` | ||
359 | /// fn foo(a: u32) ❰ -> Option<u32> ❱ { Some(a) } | ||
360 | /// ``` | ||
361 | /// | ||
362 | /// [Reference](https://doc.rust-lang.org/reference/items/functions.html) | ||
363 | struct RetType { T![->], TypeRef } | ||
364 | |||
365 | /// Struct definition. | ||
366 | /// Includes all of its attributes and doc comments. | ||
367 | /// | ||
368 | /// ``` | ||
369 | /// ❰ | ||
370 | /// /// Docs | ||
371 | /// #[attr] | ||
372 | /// struct Foo<T> where T: Debug { | ||
373 | /// /// Docs | ||
374 | /// #[attr] | ||
375 | /// pub a: u32, | ||
376 | /// b: T, | ||
377 | /// } | ||
378 | /// ❱ | ||
379 | /// | ||
380 | /// ❰ struct Foo; ❱ | ||
381 | /// ❰ struct Foo<T>(#[attr] T) where T: Debug; ❱ | ||
382 | /// ``` | ||
383 | /// | ||
384 | /// [Reference](https://doc.rust-lang.org/reference/items/structs.html) | ||
385 | struct StructDef: VisibilityOwner, NameOwner, TypeParamsOwner, AttrsOwner, DocCommentsOwner { | ||
386 | T![struct], | ||
387 | FieldDefList, | ||
388 | T![;] | ||
389 | } | ||
390 | |||
391 | /// Union definition. | ||
392 | /// Includes all of its attributes and doc comments. | ||
393 | /// | ||
394 | /// ``` | ||
395 | /// ❰ | ||
396 | /// /// Docs | ||
397 | /// #[attr] | ||
398 | /// pub union Foo<T> where T: Debug { | ||
399 | /// /// Docs | ||
400 | /// #[attr] | ||
401 | /// a: T, | ||
402 | /// b: u32, | ||
403 | /// } | ||
404 | /// ❱ | ||
405 | /// ``` | ||
406 | /// | ||
407 | /// [Reference](https://doc.rust-lang.org/reference/items/unions.html) | ||
408 | struct UnionDef: VisibilityOwner, NameOwner, TypeParamsOwner, AttrsOwner, DocCommentsOwner { | ||
409 | T![union], | ||
410 | RecordFieldDefList, | ||
411 | } | ||
412 | |||
413 | /// Record field definition list including enclosing curly braces. | ||
414 | /// | ||
415 | /// ``` | ||
416 | /// struct Foo // same for union | ||
417 | /// ❰ | ||
418 | /// { | ||
419 | /// a: u32, | ||
420 | /// b: bool, | ||
421 | /// } | ||
422 | /// ❱ | ||
423 | /// ``` | ||
424 | /// | ||
425 | /// [Reference](https://doc.rust-lang.org/reference/items/structs.html) | ||
426 | struct RecordFieldDefList { T!['{'], fields: [RecordFieldDef], T!['}'] } | ||
427 | |||
428 | /// Record field definition including its attributes and doc comments. | ||
429 | /// | ||
430 | /// ` `` | ||
431 | /// same for union | ||
432 | /// struct Foo { | ||
433 | /// ❰ | ||
434 | /// /// Docs | ||
435 | /// #[attr] | ||
436 | /// pub a: u32 | ||
437 | /// ❱ | ||
438 | /// | ||
439 | /// ❰ b: bool ❱ | ||
440 | /// } | ||
441 | /// ``` | ||
442 | /// | ||
443 | /// [Reference](https://doc.rust-lang.org/reference/items/structs.html) | ||
444 | struct RecordFieldDef: VisibilityOwner, NameOwner, AttrsOwner, DocCommentsOwner, TypeAscriptionOwner { } | ||
445 | |||
446 | /// Tuple field definition list including enclosing parens. | ||
447 | /// | ||
448 | /// ``` | ||
449 | /// struct Foo ❰ (u32, String, Vec<u32>) ❱; | ||
450 | /// ``` | ||
451 | /// | ||
452 | /// [Reference](https://doc.rust-lang.org/reference/items/structs.html) | ||
453 | struct TupleFieldDefList { T!['('], fields: [TupleFieldDef], T![')'] } | ||
454 | |||
455 | /// Tuple field definition including its attributes. | ||
456 | /// | ||
457 | /// ``` | ||
458 | /// struct Foo(❰ #[attr] u32 ❱); | ||
459 | /// ``` | ||
460 | /// | ||
461 | /// [Reference](https://doc.rust-lang.org/reference/items/structs.html) | ||
462 | struct TupleFieldDef: VisibilityOwner, AttrsOwner { | ||
463 | TypeRef, | ||
464 | } | ||
465 | |||
466 | /// Enum definition. | ||
467 | /// Includes all of its attributes and doc comments. | ||
468 | /// | ||
469 | /// ``` | ||
470 | /// ❰ | ||
471 | /// /// Docs | ||
472 | /// #[attr] | ||
473 | /// pub enum Foo<T> where T: Debug { | ||
474 | /// /// Docs | ||
475 | /// #[attr] | ||
476 | /// Bar, | ||
477 | /// Baz(#[attr] u32), | ||
478 | /// Bruh { | ||
479 | /// a: u32, | ||
480 | /// /// Docs | ||
481 | /// #[attr] | ||
482 | /// b: T, | ||
483 | /// } | ||
484 | /// } | ||
485 | /// ❱ | ||
486 | /// ``` | ||
487 | /// | ||
488 | /// [Reference](https://doc.rust-lang.org/reference/items/enumerations.html) | ||
489 | struct EnumDef: VisibilityOwner, NameOwner, TypeParamsOwner, AttrsOwner, DocCommentsOwner { | ||
490 | T![enum], | ||
491 | variant_list: EnumVariantList, | ||
492 | } | ||
493 | |||
494 | /// Enum variant definition list including enclosing curly braces. | ||
495 | /// | ||
496 | /// ``` | ||
497 | /// enum Foo | ||
498 | /// ❰ | ||
499 | /// { | ||
500 | /// Bar, | ||
501 | /// Baz(u32), | ||
502 | /// Bruh { | ||
503 | /// a: u32 | ||
504 | /// } | ||
505 | /// } | ||
506 | /// ❱ | ||
507 | /// ``` | ||
508 | /// | ||
509 | /// [Reference](https://doc.rust-lang.org/reference/items/enumerations.html) | ||
510 | struct EnumVariantList { | ||
511 | T!['{'], | ||
512 | variants: [EnumVariant], | ||
513 | T!['}'] | ||
514 | } | ||
515 | |||
516 | /// Enum variant definition including its attributes and discriminant value definition. | ||
517 | /// | ||
518 | /// ``` | ||
519 | /// enum Foo { | ||
520 | /// ❰ | ||
521 | /// /// Docs | ||
522 | /// #[attr] | ||
523 | /// Bar | ||
524 | /// ❱ | ||
525 | /// | ||
526 | /// // same for tuple and record variants | ||
527 | /// } | ||
528 | /// ``` | ||
529 | /// | ||
530 | /// [Reference](https://doc.rust-lang.org/reference/items/enumerations.html) | ||
531 | struct EnumVariant: VisibilityOwner, NameOwner, DocCommentsOwner, AttrsOwner { | ||
532 | FieldDefList, | ||
533 | T![=], | ||
534 | Expr | ||
535 | } | ||
536 | |||
537 | /// Trait definition. | ||
538 | /// Includes all of its attributes and doc comments. | ||
539 | /// | ||
540 | /// ``` | ||
541 | /// ❰ | ||
542 | /// /// Docs | ||
543 | /// #[attr] | ||
544 | /// pub unsafe trait Foo<T>: Debug where T: Debug { | ||
545 | /// // ... | ||
546 | /// } | ||
547 | /// ❱ | ||
548 | /// ``` | ||
549 | /// | ||
550 | /// [Reference](https://doc.rust-lang.org/reference/items/traits.html) | ||
551 | struct TraitDef: VisibilityOwner, NameOwner, AttrsOwner, DocCommentsOwner, TypeParamsOwner, TypeBoundsOwner { | ||
552 | T![unsafe], | ||
553 | T![auto], | ||
554 | T![trait], | ||
555 | ItemList, | ||
556 | } | ||
557 | |||
558 | /// Module definition either with body or not. | ||
559 | /// Includes all of its inner and outer attributes, module items, doc comments. | ||
560 | /// | ||
561 | /// ``` | ||
562 | /// ❰ | ||
563 | /// /// Docs | ||
564 | /// #[attr] | ||
565 | /// pub mod foo; | ||
566 | /// ❱ | ||
567 | /// | ||
568 | /// ❰ | ||
569 | /// /// Docs | ||
570 | /// #[attr] | ||
571 | /// pub mod bar { | ||
572 | /// //! Inner docs | ||
573 | /// #![inner_attr] | ||
574 | /// } | ||
575 | /// ❱ | ||
576 | /// ``` | ||
577 | /// | ||
578 | /// [Reference](https://doc.rust-lang.org/reference/items/modules.html) | ||
579 | struct Module: VisibilityOwner, NameOwner, AttrsOwner, DocCommentsOwner { | ||
580 | T![mod], | ||
581 | ItemList, | ||
582 | T![;] | ||
583 | } | ||
584 | |||
585 | /// Item defintion list. | ||
586 | /// This is used for both top-level items and impl block items. | ||
587 | /// | ||
588 | /// ``` | ||
589 | /// ❰ | ||
590 | /// fn foo {} | ||
591 | /// struct Bar; | ||
592 | /// enum Baz; | ||
593 | /// trait Bruh; | ||
594 | /// const BRUUH: u32 = 42; | ||
595 | /// ❱ | ||
596 | /// | ||
597 | /// impl Foo | ||
598 | /// ❰ | ||
599 | /// { | ||
600 | /// fn bar() {} | ||
601 | /// const BAZ: u32 = 42; | ||
602 | /// } | ||
603 | /// ❱ | ||
604 | /// ``` | ||
605 | /// | ||
606 | /// [Reference](https://doc.rust-lang.org/reference/items.html) | ||
607 | struct ItemList: ModuleItemOwner { | ||
608 | T!['{'], | ||
609 | assoc_items: [AssocItem], | ||
610 | T!['}'] | ||
611 | } | ||
612 | |||
613 | /// Constant variable definition. | ||
614 | /// Includes all of its attributes and doc comments. | ||
615 | /// | ||
616 | /// ``` | ||
617 | /// ❰ | ||
618 | /// /// Docs | ||
619 | /// #[attr] | ||
620 | /// pub const FOO: u32 = 42; | ||
621 | /// ❱ | ||
622 | /// ``` | ||
623 | /// | ||
624 | /// [Reference](https://doc.rust-lang.org/reference/items/constant-items.html) | ||
625 | struct ConstDef: VisibilityOwner, NameOwner, TypeParamsOwner, AttrsOwner, DocCommentsOwner, TypeAscriptionOwner { | ||
626 | T![default], | ||
627 | T![const], | ||
628 | T![=], | ||
629 | body: Expr, | ||
630 | T![;] | ||
631 | } | ||
632 | |||
633 | |||
634 | /// Static variable definition. | ||
635 | /// Includes all of its attributes and doc comments. | ||
636 | /// | ||
637 | /// ``` | ||
638 | /// ❰ | ||
639 | /// /// Docs | ||
640 | /// #[attr] | ||
641 | /// pub static mut FOO: u32 = 42; | ||
642 | /// ❱ | ||
643 | /// ``` | ||
644 | /// | ||
645 | /// [Reference](https://doc.rust-lang.org/reference/items/static-items.html) | ||
646 | struct StaticDef: VisibilityOwner, NameOwner, TypeParamsOwner, AttrsOwner, DocCommentsOwner, TypeAscriptionOwner { | ||
647 | T![static], | ||
648 | T![mut], | ||
649 | T![=], | ||
650 | body: Expr, | ||
651 | T![;] | ||
652 | } | ||
653 | |||
654 | /// Type alias definition. | ||
655 | /// Includes associated type clauses with type bounds. | ||
656 | /// | ||
657 | /// ``` | ||
658 | /// ❰ | ||
659 | /// /// Docs | ||
660 | /// #[attr] | ||
661 | /// pub type Foo<T> where T: Debug = T; | ||
662 | /// ❱ | ||
663 | /// | ||
664 | /// trait Bar { | ||
665 | /// ❰ type Baz: Debug; ❱ | ||
666 | /// ❰ type Bruh = String; ❱ | ||
667 | /// ❰ type Bruuh: Debug = u32; ❱ | ||
668 | /// } | ||
669 | /// ``` | ||
670 | /// | ||
671 | /// [Reference](https://doc.rust-lang.org/reference/items/type-aliases.html) | ||
672 | struct TypeAliasDef: VisibilityOwner, NameOwner, TypeParamsOwner, AttrsOwner, DocCommentsOwner, TypeBoundsOwner { | ||
673 | T![default], | ||
674 | T![type], | ||
675 | T![=], | ||
676 | TypeRef, | ||
677 | T![;] | ||
678 | } | ||
679 | |||
680 | /// Inherent and trait impl definition. | ||
681 | /// Includes all of its inner and outer attributes. | ||
682 | /// | ||
683 | /// ``` | ||
684 | /// ❰ | ||
685 | /// #[attr] | ||
686 | /// unsafe impl<T> const !Foo for Bar where T: Debug { | ||
687 | /// #![inner_attr] | ||
688 | /// // ... | ||
689 | /// } | ||
690 | /// ❱ | ||
691 | /// ``` | ||
692 | /// | ||
693 | /// [Reference](https://doc.rust-lang.org/reference/items/implementations.html) | ||
694 | struct ImplDef: TypeParamsOwner, AttrsOwner, DocCommentsOwner { | ||
695 | T![default], | ||
696 | T![const], | ||
697 | T![unsafe], | ||
698 | T![impl], | ||
699 | T![!], | ||
700 | T![for], | ||
701 | ItemList, | ||
702 | } | ||
703 | |||
704 | |||
705 | /// Parenthesized type reference. | ||
706 | /// Note: parens are only used for grouping, this is not a tuple type. | ||
707 | /// | ||
708 | /// ``` | ||
709 | /// // This is effectively just `u32`. | ||
710 | /// // Single-item tuple must be defined with a trailing comma: `(u32,)` | ||
711 | /// type Foo = ❰ (u32) ❱; | ||
712 | /// | ||
713 | /// let bar: &'static ❰ (dyn Debug) ❱ = "bruh"; | ||
714 | /// ``` | ||
715 | struct ParenType { T!['('], TypeRef, T![')'] } | ||
716 | |||
717 | /// Unnamed tuple type. | ||
718 | /// | ||
719 | /// ``` | ||
720 | /// let foo: ❰ (u32, bool) ❱ = (42, true); | ||
721 | /// ``` | ||
722 | /// | ||
723 | /// [Reference](https://doc.rust-lang.org/reference/types/tuple.html) | ||
724 | struct TupleType { T!['('], fields: [TypeRef], T![')'] } | ||
725 | |||
726 | /// The never type (i.e. the exclamation point). | ||
727 | /// | ||
728 | /// ``` | ||
729 | /// type T = ❰ ! ❱; | ||
730 | /// | ||
731 | /// fn no_return() -> ❰ ! ❱ { | ||
732 | /// loop {} | ||
733 | /// } | ||
734 | /// ``` | ||
735 | /// | ||
736 | /// [Reference](https://doc.rust-lang.org/reference/types/never.html) | ||
737 | struct NeverType { T![!] } | ||
738 | |||
739 | /// Path to a type. | ||
740 | /// Includes single identifier type names and elaborate paths with | ||
741 | /// generic parameters. | ||
742 | /// | ||
743 | /// ``` | ||
744 | /// type Foo = ❰ String ❱; | ||
745 | /// type Bar = ❰ std::vec::Vec<T> ❱; | ||
746 | /// type Baz = ❰ ::bruh::<Bruuh as Iterator>::Item ❱; | ||
747 | /// ``` | ||
748 | /// | ||
749 | /// [Reference](https://doc.rust-lang.org/reference/paths.html) | ||
750 | struct PathType { Path } | ||
751 | |||
752 | /// Raw pointer type. | ||
753 | /// | ||
754 | /// ``` | ||
755 | /// type Foo = ❰ *const u32 ❱; | ||
756 | /// type Bar = ❰ *mut u32 ❱; | ||
757 | /// ``` | ||
758 | /// | ||
759 | /// [Reference](https://doc.rust-lang.org/reference/types/pointer.html#raw-pointers-const-and-mut) | ||
760 | struct PointerType { T![*], T![const], T![mut], TypeRef } | ||
761 | |||
762 | /// Array type. | ||
763 | /// | ||
764 | /// ``` | ||
765 | /// type Foo = ❰ [u32; 24 - 3] ❱; | ||
766 | /// ``` | ||
767 | /// | ||
768 | /// [Reference](https://doc.rust-lang.org/reference/types/array.html) | ||
769 | struct ArrayType { T!['['], TypeRef, T![;], Expr, T![']'] } | ||
770 | |||
771 | /// Slice type. | ||
772 | /// | ||
773 | /// ``` | ||
774 | /// type Foo = ❰ [u8] ❱; | ||
775 | /// ``` | ||
776 | /// | ||
777 | /// [Reference](https://doc.rust-lang.org/reference/types/slice.html) | ||
778 | struct SliceType { T!['['], TypeRef, T![']'] } | ||
779 | |||
780 | /// Reference type. | ||
781 | /// | ||
782 | /// ``` | ||
783 | /// type Foo = ❰ &'static str ❱; | ||
784 | /// ``` | ||
785 | /// | ||
786 | /// [Reference](https://doc.rust-lang.org/reference/types/pointer.html) | ||
787 | struct ReferenceType { T![&], T![lifetime], T![mut], TypeRef } | ||
788 | |||
789 | /// Placeholder type (i.e. the underscore). | ||
790 | /// | ||
791 | /// ``` | ||
792 | /// let foo: ❰ _ ❱ = 42_u32; | ||
793 | /// ``` | ||
794 | /// | ||
795 | /// [Reference](https://doc.rust-lang.org/reference/types/inferred.html) | ||
796 | struct PlaceholderType { T![_] } | ||
797 | |||
798 | /// Function pointer type (not to be confused with `Fn*` family of traits). | ||
799 | /// | ||
800 | /// ``` | ||
801 | /// type Foo = ❰ async fn(#[attr] u32, named: bool) -> u32 ❱; | ||
802 | /// | ||
803 | /// type Bar = ❰ extern "C" fn(variadic: u32, #[attr] ...) ❱; | ||
804 | /// ``` | ||
805 | /// | ||
806 | /// [Reference](https://doc.rust-lang.org/reference/types/function-pointer.html) | ||
807 | struct FnPointerType { Abi, T![unsafe], T![fn], ParamList, RetType } | ||
808 | |||
809 | /// Higher order type. | ||
810 | /// | ||
811 | /// ``` | ||
812 | /// type Foo = ❰ for<'a> fn(&'a str) ❱; | ||
813 | /// ``` | ||
814 | /// | ||
815 | /// [Reference](https://doc.rust-lang.org/nomicon/hrtb.html) | ||
816 | struct ForType { T![for], TypeParamList, TypeRef } | ||
817 | |||
818 | /// Opaque `impl Trait` type. | ||
819 | /// | ||
820 | /// ``` | ||
821 | /// fn foo(bar: ❰ impl Debug + Eq ❱) {} | ||
822 | /// ``` | ||
823 | /// | ||
824 | /// [Reference](https://doc.rust-lang.org/reference/types/impl-trait.html) | ||
825 | struct ImplTraitType: TypeBoundsOwner { T![impl] } | ||
826 | |||
827 | /// Trait object type. | ||
828 | /// | ||
829 | /// ``` | ||
830 | /// type Foo = ❰ dyn Debug ❱; | ||
831 | /// ``` | ||
832 | /// | ||
833 | /// [Reference](https://doc.rust-lang.org/reference/types/trait-object.html) | ||
834 | struct DynTraitType: TypeBoundsOwner { T![dyn] } | ||
835 | |||
836 | /// Tuple literal. | ||
837 | /// | ||
838 | /// ``` | ||
839 | /// ❰ (42, true) ❱; | ||
840 | /// ``` | ||
841 | /// | ||
842 | /// [Reference](https://doc.rust-lang.org/reference/expressions/tuple-expr.html) | ||
843 | struct TupleExpr: AttrsOwner { T!['('], exprs: [Expr], T![')'] } | ||
844 | |||
845 | /// Array literal. | ||
846 | /// | ||
847 | /// ``` | ||
848 | /// ❰ [#![inner_attr] true, false, true] ❱; | ||
849 | /// | ||
850 | /// ❰ ["baz"; 24] ❱; | ||
851 | /// ``` | ||
852 | /// | ||
853 | /// [Reference](https://doc.rust-lang.org/reference/expressions/array-expr.html) | ||
854 | struct ArrayExpr: AttrsOwner { T!['['], exprs: [Expr], T![;], T![']'] } | ||
855 | |||
856 | /// Parenthesized expression. | ||
857 | /// Note: parens are only used for grouping, this is not a tuple literal. | ||
858 | /// | ||
859 | /// ``` | ||
860 | /// ❰ (#![inner_attr] 2 + 2) ❱ * 2; | ||
861 | /// ``` | ||
862 | /// | ||
863 | /// [Reference](https://doc.rust-lang.org/reference/expressions/grouped-expr.html) | ||
864 | struct ParenExpr: AttrsOwner { T!['('], Expr, T![')'] } | ||
865 | |||
866 | /// Path to a symbol in expression context. | ||
867 | /// Includes single identifier variable names and elaborate paths with | ||
868 | /// generic parameters. | ||
869 | /// | ||
870 | /// ``` | ||
871 | /// ❰ Some::<i32> ❱; | ||
872 | /// ❰ foo ❱ + 42; | ||
873 | /// ❰ Vec::<i32>::push ❱; | ||
874 | /// ❰ <[i32]>::reverse ❱; | ||
875 | /// ❰ <String as std::borrow::Borrow<str>>::borrow ❱; | ||
876 | /// ``` | ||
877 | /// | ||
878 | /// [Reference](https://doc.rust-lang.org/reference/expressions/path-expr.html) | ||
879 | struct PathExpr { Path } | ||
880 | |||
881 | /// Anonymous callable object literal a.k.a. closure, lambda or functor. | ||
882 | /// | ||
883 | /// ``` | ||
884 | /// ❰ || 42 ❱; | ||
885 | /// ❰ |a: u32| val + 1 ❱; | ||
886 | /// ❰ async |#[attr] Pattern(_): Pattern| { bar } ❱; | ||
887 | /// ❰ move || baz ❱; | ||
888 | /// ❰ || -> u32 { closure_with_ret_type_annotation_requires_block_expr } ❱ | ||
889 | /// ``` | ||
890 | /// | ||
891 | /// [Reference](https://doc.rust-lang.org/reference/expressions/closure-expr.html) | ||
892 | struct LambdaExpr: AttrsOwner { | ||
893 | T![static], // Note(@matklad): I belive this is (used to be?) syntax for generators | ||
894 | T![async], | ||
895 | T![move], | ||
896 | ParamList, | ||
897 | RetType, | ||
898 | body: Expr, | ||
899 | } | ||
900 | |||
901 | /// If expression. Includes both regular `if` and `if let` forms. | ||
902 | /// Beware that `else if` is a special case syntax sugar, because in general | ||
903 | /// there has to be block expression after `else`. | ||
904 | /// | ||
905 | /// ``` | ||
906 | /// ❰ if bool_cond { 42 } ❱ | ||
907 | /// ❰ if bool_cond { 42 } else { 24 } ❱ | ||
908 | /// ❰ if bool_cond { 42 } else if bool_cond2 { 42 } ❱ | ||
909 | /// | ||
910 | /// ❰ | ||
911 | /// if let Pattern(foo) = bar { | ||
912 | /// foo | ||
913 | /// } else { | ||
914 | /// panic!(); | ||
915 | /// } | ||
916 | /// ❱ | ||
917 | /// ``` | ||
918 | /// | ||
919 | /// [Reference](https://doc.rust-lang.org/reference/expressions/if-expr.html) | ||
920 | struct IfExpr: AttrsOwner { T![if], Condition } | ||
921 | |||
922 | /// Unconditional loop expression. | ||
923 | /// | ||
924 | /// ``` | ||
925 | /// ❰ | ||
926 | /// loop { | ||
927 | /// // yeah, it's that simple... | ||
928 | /// } | ||
929 | /// ❱ | ||
930 | /// ``` | ||
931 | /// | ||
932 | /// [Reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html) | ||
933 | struct LoopExpr: AttrsOwner, LoopBodyOwner { T![loop] } | ||
934 | |||
935 | /// Block expression with an optional prefix (label, try ketword, | ||
936 | /// unsafe keyword, async keyword...). | ||
937 | /// | ||
938 | /// ``` | ||
939 | /// ❰ | ||
940 | /// 'label: try { | ||
941 | /// None? | ||
942 | /// } | ||
943 | /// ❱ | ||
944 | /// ``` | ||
945 | /// | ||
946 | /// - [try block](https://doc.rust-lang.org/unstable-book/language-features/try-blocks.html) | ||
947 | /// - [unsafe block](https://doc.rust-lang.org/reference/expressions/block-expr.html#unsafe-blocks) | ||
948 | /// - [async block](https://doc.rust-lang.org/reference/expressions/block-expr.html#async-blocks) | ||
949 | struct EffectExpr: AttrsOwner { Label, T![try], T![unsafe], T![async], BlockExpr } | ||
950 | |||
951 | |||
952 | /// For loop expression. | ||
953 | /// Note: record struct literals are not valid as iterable expression | ||
954 | /// due to ambiguity. | ||
955 | /// | ||
956 | /// ``` | ||
957 | /// ❰ | ||
958 | /// for i in (0..4) { | ||
959 | /// dbg!(i); | ||
960 | /// } | ||
961 | /// ❱ | ||
962 | /// ``` | ||
963 | /// | ||
964 | /// [Reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html#iterator-loops) | ||
965 | struct ForExpr: AttrsOwner, LoopBodyOwner { | ||
966 | T![for], | ||
967 | Pat, | ||
968 | T![in], | ||
969 | iterable: Expr, | ||
970 | } | ||
971 | |||
972 | /// While loop expression. Includes both regular `while` and `while let` forms. | ||
973 | /// | ||
974 | /// ``` | ||
975 | /// ❰ | ||
976 | /// while bool_cond { | ||
977 | /// 42; | ||
978 | /// } | ||
979 | /// ❱ | ||
980 | /// ❰ | ||
981 | /// while let Pattern(foo) = bar { | ||
982 | /// bar += 1; | ||
983 | /// } | ||
984 | /// ❱ | ||
985 | /// ``` | ||
986 | /// | ||
987 | /// [Reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html#predicate-loops) | ||
988 | struct WhileExpr: AttrsOwner, LoopBodyOwner { T![while], Condition } | ||
989 | |||
990 | /// Continue expression. | ||
991 | /// | ||
992 | /// ``` | ||
993 | /// while bool_cond { | ||
994 | /// ❰ continue ❱; | ||
995 | /// } | ||
996 | /// | ||
997 | /// 'outer: loop { | ||
998 | /// loop { | ||
999 | /// ❰ continue 'outer ❱; | ||
1000 | /// } | ||
1001 | /// } | ||
1002 | /// | ||
1003 | /// ``` | ||
1004 | /// | ||
1005 | /// [Reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html#continue-expressions) | ||
1006 | struct ContinueExpr: AttrsOwner { T![continue], T![lifetime] } | ||
1007 | |||
1008 | /// Break expression. | ||
1009 | /// | ||
1010 | /// ``` | ||
1011 | /// while bool_cond { | ||
1012 | /// ❰ break ❱; | ||
1013 | /// } | ||
1014 | /// 'outer: loop { | ||
1015 | /// for foo in bar { | ||
1016 | /// ❰ break 'outer ❱; | ||
1017 | /// } | ||
1018 | /// } | ||
1019 | /// 'outer: loop { | ||
1020 | /// loop { | ||
1021 | /// ❰ break 'outer 42 ❱; | ||
1022 | /// } | ||
1023 | /// } | ||
1024 | /// ``` | ||
1025 | /// | ||
1026 | /// [Refernce](https://doc.rust-lang.org/reference/expressions/loop-expr.html#break-expressions) | ||
1027 | struct BreakExpr: AttrsOwner { T![break], T![lifetime], Expr } | ||
1028 | |||
1029 | /// Label. | ||
1030 | /// | ||
1031 | /// ``` | ||
1032 | /// ❰ 'outer: ❱ loop {} | ||
1033 | /// | ||
1034 | /// let foo = ❰ 'bar: ❱ loop {} | ||
1035 | /// | ||
1036 | /// ❰ 'baz: ❱ { | ||
1037 | /// break 'baz; | ||
1038 | /// } | ||
1039 | /// ``` | ||
1040 | /// | ||
1041 | /// [Reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html?highlight=label#loop-labels) | ||
1042 | /// [Labels for blocks RFC](https://github.com/rust-lang/rfcs/blob/master/text/2046-label-break-value.md) | ||
1043 | struct Label { T![lifetime] } | ||
1044 | |||
1045 | /// Block expression. Includes unsafe blocks and block labels. | ||
1046 | /// | ||
1047 | /// ``` | ||
1048 | /// let foo = ❰ | ||
1049 | /// { | ||
1050 | /// #![inner_attr] | ||
1051 | /// ❰ { } ❱ | ||
1052 | /// | ||
1053 | /// ❰ 'label: { break 'label } ❱ | ||
1054 | /// } | ||
1055 | /// ❱; | ||
1056 | /// ``` | ||
1057 | /// | ||
1058 | /// [Reference](https://doc.rust-lang.org/reference/expressions/block-expr.html) | ||
1059 | /// [Labels for blocks RFC](https://github.com/rust-lang/rfcs/blob/master/text/2046-label-break-value.md) | ||
1060 | struct BlockExpr: AttrsOwner, ModuleItemOwner { | ||
1061 | Label, T!['{'], statements: [Stmt], Expr, T!['}'], | ||
1062 | } | ||
1063 | |||
1064 | /// Return expression. | ||
1065 | /// | ||
1066 | /// ``` | ||
1067 | /// || ❰ return 42 ❱; | ||
1068 | /// | ||
1069 | /// fn bar() { | ||
1070 | /// ❰ return ❱; | ||
1071 | /// } | ||
1072 | /// ``` | ||
1073 | /// | ||
1074 | /// [Reference](https://doc.rust-lang.org/reference/expressions/return-expr.html) | ||
1075 | struct ReturnExpr: AttrsOwner { Expr } | ||
1076 | |||
1077 | /// Call expression (not to be confused with method call expression, it is | ||
1078 | /// a separate ast node). | ||
1079 | /// | ||
1080 | /// ``` | ||
1081 | /// ❰ foo() ❱; | ||
1082 | /// ❰ &str::len("bar") ❱; | ||
1083 | /// ❰ <&str as PartialEq<&str>>::eq(&"", &"") ❱; | ||
1084 | /// ``` | ||
1085 | /// | ||
1086 | /// [Reference](https://doc.rust-lang.org/reference/expressions/call-expr.html) | ||
1087 | struct CallExpr: ArgListOwner { Expr } | ||
1088 | |||
1089 | /// Method call expression. | ||
1090 | /// | ||
1091 | /// ``` | ||
1092 | /// ❰ receiver_expr.method() ❱; | ||
1093 | /// ❰ receiver_expr.method::<T>(42, true) ❱; | ||
1094 | /// | ||
1095 | /// ❰ ❰ ❰ foo.bar() ❱ .baz() ❱ .bruh() ❱; | ||
1096 | /// ``` | ||
1097 | /// | ||
1098 | /// [Reference](https://doc.rust-lang.org/reference/expressions/method-call-expr.html) | ||
1099 | struct MethodCallExpr: AttrsOwner, ArgListOwner { | ||
1100 | Expr, T![.], NameRef, TypeArgList, | ||
1101 | } | ||
1102 | |||
1103 | /// Index expression a.k.a. subscript operator call. | ||
1104 | /// | ||
1105 | /// ``` | ||
1106 | /// ❰ foo[42] ❱; | ||
1107 | /// ``` | ||
1108 | /// | ||
1109 | /// [Reference](https://doc.rust-lang.org/reference/expressions/array-expr.html) | ||
1110 | struct IndexExpr: AttrsOwner { T!['['], T![']'] } | ||
1111 | |||
1112 | /// Field access expression. | ||
1113 | /// | ||
1114 | /// ``` | ||
1115 | /// ❰ expr.bar ❱; | ||
1116 | /// | ||
1117 | /// ❰ ❰ ❰ foo.bar ❱ .baz ❱ .bruh ❱; | ||
1118 | /// ``` | ||
1119 | /// | ||
1120 | /// [Reference](https://doc.rust-lang.org/reference/expressions/field-expr.html) | ||
1121 | struct FieldExpr: AttrsOwner { Expr, T![.], NameRef } | ||
1122 | |||
1123 | /// Await operator call expression. | ||
1124 | /// | ||
1125 | /// ``` | ||
1126 | /// ❰ expr.await ❱; | ||
1127 | /// ``` | ||
1128 | /// | ||
1129 | /// [Reference](https://doc.rust-lang.org/reference/expressions/await-expr.html) | ||
1130 | struct AwaitExpr: AttrsOwner { Expr, T![.], T![await] } | ||
1131 | |||
1132 | /// The question mark operator call. | ||
1133 | /// | ||
1134 | /// ``` | ||
1135 | /// ❰ expr? ❱; | ||
1136 | /// ``` | ||
1137 | /// | ||
1138 | /// [Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#the-question-mark-operator) | ||
1139 | struct TryExpr: AttrsOwner { Expr, T![?] } | ||
1140 | |||
1141 | /// Type cast expression. | ||
1142 | /// | ||
1143 | /// ``` | ||
1144 | /// ❰ expr as T ❱; | ||
1145 | /// ``` | ||
1146 | /// | ||
1147 | /// [Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions) | ||
1148 | struct CastExpr: AttrsOwner { Expr, T![as], TypeRef } | ||
1149 | |||
1150 | |||
1151 | /// Borrow operator call. | ||
1152 | /// | ||
1153 | /// ``` | ||
1154 | /// ❰ &foo ❱; | ||
1155 | /// ❰ &mut bar ❱; | ||
1156 | /// ❰ &raw const bar ❱; | ||
1157 | /// ❰ &raw mut bar ❱; | ||
1158 | /// ``` | ||
1159 | /// | ||
1160 | /// [Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#borrow-operators) | ||
1161 | struct RefExpr: AttrsOwner { T![&], T![raw], T![mut], T![const], Expr } | ||
1162 | |||
1163 | /// Prefix operator call. This is either `!` or `*` or `-`. | ||
1164 | /// | ||
1165 | /// ``` | ||
1166 | /// ❰ !foo ❱; | ||
1167 | /// ❰ *bar ❱; | ||
1168 | /// ❰ -42 ❱; | ||
1169 | /// ``` | ||
1170 | /// | ||
1171 | /// [Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html) | ||
1172 | struct PrefixExpr: AttrsOwner { /*PrefixOp,*/ Expr } | ||
1173 | |||
1174 | /// Box operator call. | ||
1175 | /// | ||
1176 | /// ``` | ||
1177 | /// ❰ box 42 ❱; | ||
1178 | /// ``` | ||
1179 | /// | ||
1180 | /// [RFC](https://github.com/rust-lang/rfcs/blob/0806be4f282144cfcd55b1d20284b43f87cbe1c6/text/0809-box-and-in-for-stdlib.md) | ||
1181 | struct BoxExpr: AttrsOwner { T![box], Expr } | ||
1182 | |||
1183 | /// Range operator call. | ||
1184 | /// | ||
1185 | /// ``` | ||
1186 | /// ❰ 0..42 ❱; | ||
1187 | /// ❰ ..42 ❱; | ||
1188 | /// ❰ 0.. ❱; | ||
1189 | /// ❰ .. ❱; | ||
1190 | /// ❰ 0..=42 ❱; | ||
1191 | /// ❰ ..=42 ❱; | ||
1192 | /// ``` | ||
1193 | /// | ||
1194 | /// [Reference](https://doc.rust-lang.org/reference/expressions/range-expr.html) | ||
1195 | struct RangeExpr: AttrsOwner { /*RangeOp*/ } | ||
1196 | |||
1197 | |||
1198 | /// Binary operator call. | ||
1199 | /// Includes all arithmetic, logic, bitwise and assignment operators. | ||
1200 | /// | ||
1201 | /// ``` | ||
1202 | /// ❰ 2 + ❰ 2 * 2 ❱ ❱; | ||
1203 | /// ❰ ❰ true && false ❱ || true ❱; | ||
1204 | /// ``` | ||
1205 | /// | ||
1206 | /// [Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators) | ||
1207 | struct BinExpr: AttrsOwner { /*BinOp*/ } | ||
1208 | |||
1209 | |||
1210 | /// [Raw] string, [raw] byte string, char, byte, integer, float or bool literal. | ||
1211 | /// | ||
1212 | /// ``` | ||
1213 | /// ❰ "str" ❱; | ||
1214 | /// ❰ br##"raw byte str"## ❱; | ||
1215 | /// ❰ 'c' ❱; | ||
1216 | /// ❰ b'c' ❱; | ||
1217 | /// ❰ 42 ❱; | ||
1218 | /// ❰ 1e9 ❱; | ||
1219 | /// ❰ true ❱; | ||
1220 | /// ``` | ||
1221 | /// | ||
1222 | /// [Reference](https://doc.rust-lang.org/reference/expressions/literal-expr.html) | ||
1223 | struct Literal { /*LiteralToken*/ } | ||
1224 | |||
1225 | /// Match expression. | ||
1226 | /// | ||
1227 | /// ``` | ||
1228 | /// ❰ | ||
1229 | /// match expr { | ||
1230 | /// Pat1 => {} | ||
1231 | /// Pat2(_) => 42, | ||
1232 | /// } | ||
1233 | /// ❱ | ||
1234 | /// ``` | ||
1235 | /// | ||
1236 | /// [Reference](https://doc.rust-lang.org/reference/expressions/match-expr.html) | ||
1237 | struct MatchExpr: AttrsOwner { T![match], Expr, MatchArmList } | ||
1238 | |||
1239 | /// Match arm list part of match expression. Includes its inner attributes. | ||
1240 | /// | ||
1241 | /// ``` | ||
1242 | /// match expr | ||
1243 | /// ❰ | ||
1244 | /// { | ||
1245 | /// #![inner_attr] | ||
1246 | /// Pat1 => {} | ||
1247 | /// Pat2(_) => 42, | ||
1248 | /// } | ||
1249 | /// ❱ | ||
1250 | /// ``` | ||
1251 | /// | ||
1252 | /// [Reference](https://doc.rust-lang.org/reference/expressions/match-expr.html) | ||
1253 | struct MatchArmList: AttrsOwner { T!['{'], arms: [MatchArm], T!['}'] } | ||
1254 | |||
1255 | |||
1256 | /// Match arm. | ||
1257 | /// Note: record struct literals are not valid as target match expression | ||
1258 | /// due to ambiguity. | ||
1259 | /// ``` | ||
1260 | /// match expr { | ||
1261 | /// ❰ #[attr] Pattern(it) if bool_cond => it ❱, | ||
1262 | /// } | ||
1263 | /// ``` | ||
1264 | /// | ||
1265 | /// [Reference](https://doc.rust-lang.org/reference/expressions/match-expr.html) | ||
1266 | struct MatchArm: AttrsOwner { | ||
1267 | pat: Pat, | ||
1268 | guard: MatchGuard, | ||
1269 | T![=>], | ||
1270 | Expr, | ||
1271 | } | ||
1272 | |||
1273 | /// Match guard. | ||
1274 | /// | ||
1275 | /// ``` | ||
1276 | /// match expr { | ||
1277 | /// Pattern(it) ❰ if bool_cond ❱ => it, | ||
1278 | /// } | ||
1279 | /// ``` | ||
1280 | /// | ||
1281 | /// [Reference](https://doc.rust-lang.org/reference/expressions/match-expr.html#match-guards) | ||
1282 | struct MatchGuard { T![if], Expr } | ||
1283 | |||
1284 | /// Record literal expression. The same syntax is used for structs, | ||
1285 | /// unions and record enum variants. | ||
1286 | /// | ||
1287 | /// ``` | ||
1288 | /// ❰ | ||
1289 | /// foo::Bar { | ||
1290 | /// #![inner_attr] | ||
1291 | /// baz: 42, | ||
1292 | /// bruh: true, | ||
1293 | /// ..spread | ||
1294 | /// } | ||
1295 | /// ❱ | ||
1296 | /// ``` | ||
1297 | /// | ||
1298 | /// [Reference](https://doc.rust-lang.org/reference/expressions/struct-expr.html) | ||
1299 | struct RecordLit { Path, RecordFieldList} | ||
1300 | |||
1301 | /// Record field list including enclosing curly braces. | ||
1302 | /// | ||
1303 | /// foo::Bar ❰ | ||
1304 | /// { | ||
1305 | /// baz: 42, | ||
1306 | /// ..spread | ||
1307 | /// } | ||
1308 | /// ❱ | ||
1309 | /// | ||
1310 | /// [Reference](https://doc.rust-lang.org/reference/expressions/struct-expr.html) | ||
1311 | struct RecordFieldList { | ||
1312 | T!['{'], | ||
1313 | fields: [RecordField], | ||
1314 | T![..], | ||
1315 | spread: Expr, | ||
1316 | T!['}'] | ||
1317 | } | ||
1318 | |||
1319 | /// Record field. | ||
1320 | /// | ||
1321 | /// ``` | ||
1322 | /// foo::Bar { | ||
1323 | /// ❰ #[attr] baz: 42 ❱ | ||
1324 | /// } | ||
1325 | /// ``` | ||
1326 | /// | ||
1327 | /// [Reference](https://doc.rust-lang.org/reference/expressions/struct-expr.html) | ||
1328 | struct RecordField: AttrsOwner { NameRef, T![:], Expr } | ||
1329 | |||
1330 | /// Disjunction of patterns. | ||
1331 | /// | ||
1332 | /// ``` | ||
1333 | /// let ❰ Foo(it) | Bar(it) | Baz(it) ❱ = bruh; | ||
1334 | /// ``` | ||
1335 | /// | ||
1336 | /// [Reference](https://doc.rust-lang.org/reference/patterns.html) | ||
1337 | struct OrPat { pats: [Pat] } | ||
1338 | |||
1339 | /// Parenthesized pattern. | ||
1340 | /// Note: parens are only used for grouping, this is not a tuple pattern. | ||
1341 | /// | ||
1342 | /// ``` | ||
1343 | /// if let ❰ &(0..=42) ❱ = foo {} | ||
1344 | /// ``` | ||
1345 | /// | ||
1346 | /// https://doc.rust-lang.org/reference/patterns.html#grouped-patterns | ||
1347 | struct ParenPat { T!['('], Pat, T![')'] } | ||
1348 | |||
1349 | /// Reference pattern. | ||
1350 | /// Note: this has nothing to do with `ref` keyword, the latter is used in bind patterns. | ||
1351 | /// | ||
1352 | /// ``` | ||
1353 | /// let ❰ &mut foo ❱ = bar; | ||
1354 | /// | ||
1355 | /// let ❰ & ❰ &mut ❰ &_ ❱ ❱ ❱ = baz; | ||
1356 | /// ``` | ||
1357 | /// | ||
1358 | /// [Reference](https://doc.rust-lang.org/reference/patterns.html#reference-patterns) | ||
1359 | struct RefPat { T![&], T![mut], Pat } | ||
1360 | |||
1361 | /// Box pattern. | ||
1362 | /// | ||
1363 | /// ``` | ||
1364 | /// let ❰ box foo ❱ = box 42; | ||
1365 | /// ``` | ||
1366 | /// | ||
1367 | /// [Unstable book](https://doc.rust-lang.org/unstable-book/language-features/box-patterns.html) | ||
1368 | struct BoxPat { T![box], Pat } | ||
1369 | |||
1370 | /// Bind pattern. | ||
1371 | /// | ||
1372 | /// ``` | ||
1373 | /// match foo { | ||
1374 | /// Some(❰ ref mut bar ❱) => {} | ||
1375 | /// ❰ baz @ None ❱ => {} | ||
1376 | /// } | ||
1377 | /// ``` | ||
1378 | /// | ||
1379 | /// [Reference](https://doc.rust-lang.org/reference/patterns.html#identifier-patterns) | ||
1380 | struct BindPat: AttrsOwner, NameOwner { T![ref], T![mut], T![@], Pat } | ||
1381 | |||
1382 | /// Placeholder pattern a.k.a. the wildcard pattern or the underscore. | ||
1383 | /// | ||
1384 | /// ``` | ||
1385 | /// let ❰ _ ❱ = foo; | ||
1386 | /// ``` | ||
1387 | /// | ||
1388 | /// [Reference](https://doc.rust-lang.org/reference/patterns.html#wildcard-pattern) | ||
1389 | struct PlaceholderPat { T![_] } | ||
1390 | |||
1391 | /// Rest-of-the record/tuple pattern. | ||
1392 | /// Note: this is not the unbonded range pattern (even more: it doesn't exist). | ||
1393 | /// | ||
1394 | /// ``` | ||
1395 | /// let Foo { bar, ❰ .. ❱ } = baz; | ||
1396 | /// let (❰ .. ❱, bruh) = (42, 24, 42); | ||
1397 | /// let Bruuh(❰ .. ❱) = bruuuh; | ||
1398 | /// ``` | ||
1399 | /// | ||
1400 | /// [Reference](https://doc.rust-lang.org/reference/patterns.html#struct-patterns) | ||
1401 | struct DotDotPat { T![..] } | ||
1402 | |||
1403 | /// Path pattern. | ||
1404 | /// Doesn't include the underscore pattern (it is a special case, namely `PlaceholderPat`). | ||
1405 | /// | ||
1406 | /// ``` | ||
1407 | /// let ❰ foo::bar::Baz ❱ { .. } = bruh; | ||
1408 | /// if let ❰ CONST ❱ = 42 {} | ||
1409 | /// ``` | ||
1410 | /// | ||
1411 | /// [Reference](https://doc.rust-lang.org/reference/patterns.html#path-patterns) | ||
1412 | struct PathPat { Path } | ||
1413 | |||
1414 | /// Slice pattern. | ||
1415 | /// | ||
1416 | /// ``` | ||
1417 | /// let ❰ [foo, bar, baz] ❱ = [1, 2, 3]; | ||
1418 | /// ``` | ||
1419 | /// | ||
1420 | /// [Reference](https://doc.rust-lang.org/reference/patterns.html#slice-patterns) | ||
1421 | struct SlicePat { T!['['], args: [Pat], T![']'] } | ||
1422 | |||
1423 | /// Range pattern. | ||
1424 | /// | ||
1425 | /// ``` | ||
1426 | /// match foo { | ||
1427 | /// ❰ 0..42 ❱ => {} | ||
1428 | /// ❰ 0..=42 ❱ => {} | ||
1429 | /// } | ||
1430 | /// ``` | ||
1431 | /// | ||
1432 | /// [Reference](https://doc.rust-lang.org/reference/patterns.html#range-patterns) | ||
1433 | struct RangePat { } // FIXME(@matklad): here should be T![..], T![..=] I think, if we don't already have an accessor in expresions_ext | ||
1434 | |||
1435 | /// Literal pattern. | ||
1436 | /// Includes only bool, number, char, and string literals. | ||
1437 | /// | ||
1438 | /// ``` | ||
1439 | /// match foo { | ||
1440 | /// Number(❰ 42 ❱) => {} | ||
1441 | /// String(❰ "42" ❱) => {} | ||
1442 | /// Bool(❰ true ❱) => {} | ||
1443 | /// } | ||
1444 | /// ``` | ||
1445 | /// | ||
1446 | /// [Reference](https://doc.rust-lang.org/reference/patterns.html#literal-patterns) | ||
1447 | struct LiteralPat { Literal } | ||
1448 | |||
1449 | /// Macro invocation in pattern position. | ||
1450 | /// | ||
1451 | /// ``` | ||
1452 | /// let ❰ foo!(my custom syntax) ❱ = baz; | ||
1453 | /// | ||
1454 | /// ``` | ||
1455 | /// [Reference](https://doc.rust-lang.org/reference/macros.html#macro-invocation) | ||
1456 | struct MacroPat { MacroCall } | ||
1457 | |||
1458 | /// Record literal pattern. | ||
1459 | /// | ||
1460 | /// ``` | ||
1461 | /// let ❰ foo::Bar { baz, .. } ❱ = bruh; | ||
1462 | /// ``` | ||
1463 | /// | ||
1464 | /// [Reference](https://doc.rust-lang.org/reference/patterns.html#struct-patterns) | ||
1465 | struct RecordPat { RecordFieldPatList, Path } | ||
1466 | |||
1467 | /// Record literal's field patterns list including enclosing curly braces. | ||
1468 | /// | ||
1469 | /// ``` | ||
1470 | /// let foo::Bar ❰ { baz, bind @ bruh, .. } ❱ = bruuh; | ||
1471 | /// `` | ||
1472 | /// | ||
1473 | /// [Reference](https://doc.rust-lang.org/reference/patterns.html#struct-patterns) | ||
1474 | struct RecordFieldPatList { | ||
1475 | T!['{'], | ||
1476 | pats: [RecordInnerPat], | ||
1477 | record_field_pats: [RecordFieldPat], | ||
1478 | bind_pats: [BindPat], | ||
1479 | T![..], | ||
1480 | T!['}'] | ||
1481 | } | ||
1482 | |||
1483 | /// Record literal's field pattern. | ||
1484 | /// Note: record literal can also match tuple structs. | ||
1485 | /// | ||
1486 | /// ``` | ||
1487 | /// let Foo { ❰ bar: _ ❱ } = baz; | ||
1488 | /// let TupleStruct { ❰ 0: _ ❱ } = bruh; | ||
1489 | /// ``` | ||
1490 | /// | ||
1491 | /// [Reference](https://doc.rust-lang.org/reference/patterns.html#struct-patterns) | ||
1492 | struct RecordFieldPat: AttrsOwner { NameRef, T![:], Pat } | ||
1493 | |||
1494 | /// Tuple struct literal pattern. | ||
1495 | /// | ||
1496 | /// ``` | ||
1497 | /// let ❰ foo::Bar(baz, bruh) ❱ = bruuh; | ||
1498 | /// ``` | ||
1499 | /// | ||
1500 | /// [Reference](https://doc.rust-lang.org/reference/patterns.html#tuple-struct-patterns) | ||
1501 | struct TupleStructPat { Path, T!['('], args: [Pat], T![')'] } | ||
1502 | |||
1503 | /// Tuple pattern. | ||
1504 | /// Note: this doesn't include tuple structs (see `TupleStructPat`) | ||
1505 | /// | ||
1506 | /// ``` | ||
1507 | /// let ❰ (foo, bar, .., baz) ❱ = bruh; | ||
1508 | /// ``` | ||
1509 | /// | ||
1510 | /// [Reference](https://doc.rust-lang.org/reference/patterns.html#tuple-patterns) | ||
1511 | struct TuplePat { T!['('], args: [Pat], T![')'] } | ||
1512 | |||
1513 | /// Visibility. | ||
1514 | /// | ||
1515 | /// ``` | ||
1516 | /// ❰ pub mod ❱ foo; | ||
1517 | /// ❰ pub(crate) ❱ struct Bar; | ||
1518 | /// ❰ pub(self) ❱ enum Baz {} | ||
1519 | /// ❰ pub(super) ❱ fn bruh() {} | ||
1520 | /// ❰ pub(in bruuh::bruuuh) ❱ type T = u64; | ||
1521 | /// ``` | ||
1522 | /// | ||
1523 | /// [Reference](https://doc.rust-lang.org/reference/visibility-and-privacy.html) | ||
1524 | struct Visibility { T![pub], T![super], T![self], T![crate] } | ||
1525 | |||
1526 | /// Single identifier. | ||
1527 | /// Note(@matklad): `Name` is for things that install a new name into the scope, | ||
1528 | /// `NameRef` is a usage of a name. Most of the time, this definition/reference | ||
1529 | /// distinction can be determined purely syntactically, ie in | ||
1530 | /// ``` | ||
1531 | /// fn foo() { foo() } | ||
1532 | /// ``` | ||
1533 | /// the first foo is `Name`, the second one is `NameRef`. | ||
1534 | /// The notable exception are patterns, where in | ||
1535 | /// `` | ||
1536 | /// let x = 92 | ||
1537 | /// ``` | ||
1538 | /// `x` can be semantically either a name or a name ref, depeding on | ||
1539 | /// wether there's an `x` constant in scope. | ||
1540 | /// We use `Name` for patterns, and disambiguate semantically (see `NameClass` in ide_db). | ||
1541 | /// | ||
1542 | /// ``` | ||
1543 | /// let ❰ foo ❱ = bar; | ||
1544 | /// struct ❰ Baz ❱; | ||
1545 | /// fn ❰ bruh ❱() {} | ||
1546 | /// ``` | ||
1547 | /// | ||
1548 | /// [Reference](https://doc.rust-lang.org/reference/identifiers.html) | ||
1549 | struct Name { T![ident] } | ||
1550 | |||
1551 | /// Reference to a name. | ||
1552 | /// See the explanation on the difference between `Name` and `NameRef` | ||
1553 | /// in `Name` ast node docs. | ||
1554 | /// | ||
1555 | /// ``` | ||
1556 | /// let foo = ❰ bar ❱(❰ Baz(❰ bruh ❱) ❱; | ||
1557 | /// ``` | ||
1558 | /// | ||
1559 | /// [Reference](https://doc.rust-lang.org/reference/identifiers.html) | ||
1560 | struct NameRef { } | ||
1561 | |||
1562 | /// Macro call. | ||
1563 | /// Includes all of its attributes and doc comments. | ||
1564 | /// | ||
1565 | /// ``` | ||
1566 | /// ❰ | ||
1567 | /// /// Docs | ||
1568 | /// #[attr] | ||
1569 | /// macro_rules! foo { // macro rules is also a macro call | ||
1570 | /// ($bar: tt) => {} | ||
1571 | /// } | ||
1572 | /// ❱ | ||
1573 | /// | ||
1574 | /// // semicolon is a part of `MacroCall` when it is used in item positions | ||
1575 | /// ❰ foo!(); ❱ | ||
1576 | /// | ||
1577 | /// fn main() { | ||
1578 | /// ❰ foo!() ❱; // macro call in expression positions doesn't include the semi | ||
1579 | /// } | ||
1580 | /// ``` | ||
1581 | /// | ||
1582 | /// [Reference](https://doc.rust-lang.org/reference/macros.html) | ||
1583 | struct MacroCall: NameOwner, AttrsOwner, DocCommentsOwner { | ||
1584 | Path, T![!], TokenTree, T![;] | ||
1585 | } | ||
1586 | |||
1587 | /// Attribute. | ||
1588 | /// | ||
1589 | /// ``` | ||
1590 | /// ❰ #![inner_attr] ❱ | ||
1591 | /// | ||
1592 | /// ❰ #[attr] ❱ | ||
1593 | /// ❰ #[foo = "bar"] ❱ | ||
1594 | /// ❰ #[baz(bruh::bruuh = "42")] ❱ | ||
1595 | /// struct Foo; | ||
1596 | /// ``` | ||
1597 | /// | ||
1598 | /// [Reference](https://doc.rust-lang.org/reference/attributes.html) | ||
1599 | struct Attr { T![#], T![!], T!['['], Path, T![=], input: AttrInput, T![']'] } | ||
1600 | |||
1601 | /// Stores a list of lexer tokens and other `TokenTree`s. | ||
1602 | /// It appears in attributes, macro_rules and macro call (foo!) | ||
1603 | /// | ||
1604 | /// ``` | ||
1605 | /// macro_call! ❰ { my syntax here } ❱; | ||
1606 | /// ``` | ||
1607 | /// | ||
1608 | /// [Reference](https://doc.rust-lang.org/reference/macros.html) | ||
1609 | struct TokenTree {} | ||
1610 | |||
1611 | /// Generic lifetime, type and constants parameters list **declaration**. | ||
1612 | /// | ||
1613 | /// ``` | ||
1614 | /// fn foo❰ <'a, 'b, T, U, const BAR: u64> ❱() {} | ||
1615 | /// | ||
1616 | /// struct Baz❰ <T> ❱(T); | ||
1617 | /// | ||
1618 | /// impl❰ <T> ❱ Bruh<T> {} | ||
1619 | /// | ||
1620 | /// type Bruuh = for❰ <'a> ❱ fn(&'a str) -> &'a str; | ||
1621 | /// ``` | ||
1622 | /// | ||
1623 | /// [Reference](https://doc.rust-lang.org/reference/items/generics.html) | ||
1624 | struct TypeParamList { | ||
1625 | T![<], | ||
1626 | generic_params: [GenericParam], | ||
1627 | type_params: [TypeParam], | ||
1628 | lifetime_params: [LifetimeParam], | ||
1629 | const_params: [ConstParam], | ||
1630 | T![>] | ||
1631 | } | ||
1632 | |||
1633 | /// Single type parameter **declaration**. | ||
1634 | /// | ||
1635 | /// ``` | ||
1636 | /// fn foo<❰ K ❱, ❰ I ❱, ❰ E: Debug ❱, ❰ V = DefaultType ❱>() {} | ||
1637 | /// ``` | ||
1638 | /// | ||
1639 | /// [Reference](https://doc.rust-lang.org/reference/items/generics.html) | ||
1640 | struct TypeParam: NameOwner, AttrsOwner, TypeBoundsOwner { | ||
1641 | T![=], | ||
1642 | default_type: TypeRef, | ||
1643 | } | ||
1644 | |||
1645 | /// Const generic parameter **declaration**. | ||
1646 | /// ``` | ||
1647 | /// fn foo<T, U, ❰ const BAR: usize ❱, ❰ const BAZ: bool ❱>() {} | ||
1648 | /// ``` | ||
1649 | /// | ||
1650 | /// [RFC](https://github.com/rust-lang/rfcs/blob/master/text/2000-const-generics.md#declaring-a-const-parameter) | ||
1651 | struct ConstParam: NameOwner, AttrsOwner, TypeAscriptionOwner { | ||
1652 | T![=], | ||
1653 | default_val: Expr, | ||
1654 | } | ||
1655 | |||
1656 | /// Lifetime parameter **declaration**. | ||
1657 | /// | ||
1658 | /// ``` | ||
1659 | /// fn foo<❰ 'a ❱, ❰ 'b ❱, V, G, D>(bar: &'a str, baz: &'b mut str) {} | ||
1660 | /// ``` | ||
1661 | /// | ||
1662 | /// [Reference](https://doc.rust-lang.org/reference/items/generics.html) | ||
1663 | struct LifetimeParam: AttrsOwner { T![lifetime] } | ||
1664 | |||
1665 | /// Type bound declaration clause. | ||
1666 | /// | ||
1667 | /// ``` | ||
1668 | /// fn foo<T: ❰ ?Sized ❱ + ❰ Debug ❱>() {} | ||
1669 | /// | ||
1670 | /// trait Bar<T> | ||
1671 | /// where | ||
1672 | /// T: ❰ Send ❱ + ❰ Sync ❱ | ||
1673 | /// { | ||
1674 | /// type Baz: ❰ !Sync ❱ + ❰ Debug ❱ + ❰ ?const Add ❱; | ||
1675 | /// } | ||
1676 | /// ``` | ||
1677 | /// | ||
1678 | /// [Reference](https://doc.rust-lang.org/reference/trait-bounds.html) | ||
1679 | struct TypeBound { T![lifetime], /* Question, */ T![const], /* Question, */ TypeRef } | ||
1680 | |||
1681 | /// Type bounds list. | ||
1682 | /// | ||
1683 | /// ``` | ||
1684 | /// | ||
1685 | /// fn foo<T: ❰ ?Sized + Debug ❱>() {} | ||
1686 | /// | ||
1687 | /// trait Bar<T> | ||
1688 | /// where | ||
1689 | /// T: ❰ Send + Sync ❱ | ||
1690 | /// { | ||
1691 | /// type Baz: ❰ !Sync + Debug ❱; | ||
1692 | /// } | ||
1693 | /// ``` | ||
1694 | /// | ||
1695 | /// [Reference](https://doc.rust-lang.org/reference/trait-bounds.html) | ||
1696 | struct TypeBoundList { bounds: [TypeBound] } | ||
1697 | |||
1698 | /// Single where predicate. | ||
1699 | /// | ||
1700 | /// ``` | ||
1701 | /// trait Foo<'a, 'b, T> | ||
1702 | /// where | ||
1703 | /// ❰ 'a: 'b ❱, | ||
1704 | /// ❰ T: IntoIterator ❱, | ||
1705 | /// ❰ for<'c> <T as IntoIterator>::Item: Bar<'c> ❱ | ||
1706 | /// {} | ||
1707 | /// ``` | ||
1708 | /// | ||
1709 | /// [Reference](https://doc.rust-lang.org/reference/items/generics.html#where-clauses) | ||
1710 | struct WherePred: TypeBoundsOwner { T![for], TypeParamList, T![lifetime], TypeRef } | ||
1711 | |||
1712 | /// Where clause. | ||
1713 | /// | ||
1714 | /// ``` | ||
1715 | /// trait Foo<'a, T> ❰ where 'a: 'static, T: Debug ❱ {} | ||
1716 | /// | ||
1717 | /// ``` | ||
1718 | /// | ||
1719 | /// [Reference](https://doc.rust-lang.org/reference/items/generics.html#where-clauses) | ||
1720 | struct WhereClause { T![where], predicates: [WherePred] } | ||
1721 | |||
1722 | /// Abi declaration. | ||
1723 | /// Note: the abi string is optional. | ||
1724 | /// | ||
1725 | /// ``` | ||
1726 | /// ❰ extern "C" ❱ { | ||
1727 | /// fn foo() {} | ||
1728 | /// } | ||
1729 | /// | ||
1730 | /// type Bar = ❰ extern ❱ fn() -> u32; | ||
1731 | /// | ||
1732 | /// type Baz = ❰ extern r#"stdcall"# ❱ fn() -> bool; | ||
1733 | /// ``` | ||
1734 | /// | ||
1735 | /// - [Extern blocks reference](https://doc.rust-lang.org/reference/items/external-blocks.html) | ||
1736 | /// - [FFI function pointers reference](https://doc.rust-lang.org/reference/items/functions.html#functions) | ||
1737 | struct Abi { /*String*/ } | ||
1738 | |||
1739 | /// Expression statement. | ||
1740 | /// | ||
1741 | /// ``` | ||
1742 | /// ❰ 42; ❱ | ||
1743 | /// ❰ foo(); ❱ | ||
1744 | /// ❰ (); ❱ | ||
1745 | /// ❰ {}; ❱ | ||
1746 | /// | ||
1747 | /// // constructions with trailing curly brace can omit the semicolon | ||
1748 | /// // but only when there are satements immediately after them (this is important!) | ||
1749 | /// ❰ if bool_cond { } ❱ | ||
1750 | /// ❰ loop {} ❱ | ||
1751 | /// ❰ somestatment; ❱ | ||
1752 | /// ``` | ||
1753 | /// | ||
1754 | /// [Reference](https://doc.rust-lang.org/reference/statements.html) | ||
1755 | struct ExprStmt: AttrsOwner { Expr, T![;] } | ||
1756 | |||
1757 | /// Let statement. | ||
1758 | /// | ||
1759 | /// ``` | ||
1760 | /// ❰ #[attr] let foo; ❱ | ||
1761 | /// ❰ let bar: u64; ❱ | ||
1762 | /// ❰ let baz = 42; ❱ | ||
1763 | /// ❰ let bruh: bool = true; ❱ | ||
1764 | /// ``` | ||
1765 | /// | ||
1766 | /// [Reference](https://doc.rust-lang.org/reference/statements.html#let-statements) | ||
1767 | struct LetStmt: AttrsOwner, TypeAscriptionOwner { | ||
1768 | T![let], | ||
1769 | Pat, | ||
1770 | T![=], | ||
1771 | initializer: Expr, | ||
1772 | T![;], | ||
1773 | } | ||
1774 | |||
1775 | /// Condition of `if` or `while` expression. | ||
1776 | /// | ||
1777 | /// ``` | ||
1778 | /// if ❰ true ❱ {} | ||
1779 | /// if ❰ let Pat(foo) = bar ❱ {} | ||
1780 | /// | ||
1781 | /// while ❰ true ❱ {} | ||
1782 | /// while ❰ let Pat(baz) = bruh ❱ {} | ||
1783 | /// ``` | ||
1784 | /// | ||
1785 | /// [If expression reference](https://doc.rust-lang.org/reference/expressions/if-expr.html) | ||
1786 | /// [While expression reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html#predicate-loops) | ||
1787 | struct Condition { T![let], Pat, T![=], Expr } | ||
1788 | |||
1789 | /// Parameter list **declaration**. | ||
1790 | /// | ||
1791 | /// ``` | ||
1792 | /// fn foo❰ (a: u32, b: bool) ❱ -> u32 {} | ||
1793 | /// let bar = ❰ |a, b| ❱ {}; | ||
1794 | /// | ||
1795 | /// impl Baz { | ||
1796 | /// fn bruh❰ (&self, a: u32) ❱ {} | ||
1797 | /// } | ||
1798 | /// ``` | ||
1799 | /// | ||
1800 | /// [Reference](https://doc.rust-lang.org/reference/items/functions.html)ocs to codegen script | ||
1801 | struct ParamList { // FIXME: this node is used by closure expressions too, but hey use pipes instead of parens... | ||
1802 | T!['('], | ||
1803 | SelfParam, | ||
1804 | params: [Param], | ||
1805 | T![')'] | ||
1806 | } | ||
1807 | |||
1808 | /// Self parameter **declaration**. | ||
1809 | /// | ||
1810 | /// ``` | ||
1811 | /// impl Bruh { | ||
1812 | /// fn foo(❰ self ❱) {} | ||
1813 | /// fn bar(❰ &self ❱) {} | ||
1814 | /// fn baz(❰ &mut self ❱) {} | ||
1815 | /// fn blah<'a>(❰ &'a self ❱) {} | ||
1816 | /// fn blin(❰ self: Box<Self> ❱) {} | ||
1817 | /// } | ||
1818 | /// ``` | ||
1819 | /// | ||
1820 | /// [Reference](https://doc.rust-lang.org/reference/items/functions.html) | ||
1821 | struct SelfParam: TypeAscriptionOwner, AttrsOwner { T![&], T![mut], T![lifetime], T![self] } | ||
1822 | |||
1823 | /// Parameter **declaration**. | ||
1824 | /// | ||
1825 | /// ``` | ||
1826 | /// fn foo(❰ #[attr] Pat(bar): Pat(u32) ❱, ❰ #[attr] _: bool ❱) {} | ||
1827 | /// | ||
1828 | /// extern "C" { | ||
1829 | /// fn bar(❰ baz: u32 ❱, ❰ ... ❱) -> u32; | ||
1830 | /// } | ||
1831 | /// ``` | ||
1832 | /// | ||
1833 | /// [Reference](https://doc.rust-lang.org/reference/items/functions.html) | ||
1834 | struct Param: TypeAscriptionOwner, AttrsOwner { | ||
1835 | Pat, | ||
1836 | T![...] | ||
1837 | } | ||
1838 | |||
1839 | /// Use declaration. | ||
1840 | /// | ||
1841 | /// ``` | ||
1842 | /// ❰ #[attr] pub use foo; ❱ | ||
1843 | /// ❰ use bar as baz; ❱ | ||
1844 | /// ❰ use bruh::{self, bruuh}; ❱ | ||
1845 | /// ❰ use { blin::blen, blah::* }; | ||
1846 | /// ``` | ||
1847 | /// | ||
1848 | /// [Reference](https://doc.rust-lang.org/reference/items/use-declarations.html) | ||
1849 | struct UseItem: AttrsOwner, VisibilityOwner { | ||
1850 | T![use], | ||
1851 | UseTree, | ||
1852 | } | ||
1853 | |||
1854 | /// Use tree. | ||
1855 | /// | ||
1856 | /// ``` | ||
1857 | /// pub use ❰ foo::❰ * ❱ ❱; | ||
1858 | /// use ❰ bar as baz ❱; | ||
1859 | /// use ❰ bruh::bruuh::{ ❰ self ❱, ❰ blin ❱ } ❱; | ||
1860 | /// use ❰ { ❰ blin::blen ❱ } ❱ | ||
1861 | /// ``` | ||
1862 | /// | ||
1863 | /// [Reference](https://doc.rust-lang.org/reference/items/use-declarations.html) | ||
1864 | struct UseTree { | ||
1865 | Path, T![*], UseTreeList, Alias | ||
1866 | } | ||
1867 | |||
1868 | /// Item alias. | ||
1869 | /// Note: this is not the type alias. | ||
1870 | /// | ||
1871 | /// ``` | ||
1872 | /// use foo ❰ as bar ❱; | ||
1873 | /// use baz::{bruh ❰ as _ ❱}; | ||
1874 | /// extern crate bruuh ❰ as blin ❱; | ||
1875 | /// ``` | ||
1876 | /// | ||
1877 | /// [Reference](https://doc.rust-lang.org/reference/items/use-declarations.html) | ||
1878 | struct Alias: NameOwner { T![as] } | ||
1879 | |||
1880 | /// Sublist of use trees. | ||
1881 | /// | ||
1882 | /// ``` | ||
1883 | /// use bruh::bruuh::❰ { ❰ self ❱, ❰ blin ❱ } ❱; | ||
1884 | /// use ❰ { blin::blen::❰ {} ❱ } ❱ | ||
1885 | /// ``` | ||
1886 | /// | ||
1887 | /// [Reference](https://doc.rust-lang.org/reference/items/use-declarations.html) | ||
1888 | struct UseTreeList { T!['{'], use_trees: [UseTree], T!['}'] } | ||
1889 | |||
1890 | /// Extern crate item. | ||
1891 | /// | ||
1892 | /// ``` | ||
1893 | /// ❰ #[attr] pub extern crate foo; ❱ | ||
1894 | /// ❰ extern crate self as bar; ❱ | ||
1895 | /// ``` | ||
1896 | /// | ||
1897 | /// [Reference](https://doc.rust-lang.org/reference/items/extern-crates.html) | ||
1898 | struct ExternCrateItem: AttrsOwner, VisibilityOwner { | ||
1899 | T![extern], T![crate], NameRef, Alias, | ||
1900 | } | ||
1901 | |||
1902 | /// Call site arguments list. | ||
1903 | /// | ||
1904 | /// ``` | ||
1905 | /// foo::<T, U>❰ (42, true) ❱; | ||
1906 | /// ``` | ||
1907 | /// | ||
1908 | /// [Reference](https://doc.rust-lang.org/reference/expressions/call-expr.html) | ||
1909 | struct ArgList { | ||
1910 | T!['('], | ||
1911 | args: [Expr], | ||
1912 | T![')'] | ||
1913 | } | ||
1914 | |||
1915 | /// Path to a symbol. Includes single identifier names and elaborate paths with | ||
1916 | /// generic parameters. | ||
1917 | /// | ||
1918 | /// ``` | ||
1919 | /// (0..10).❰ ❰ collect ❱ ::<Vec<_>> ❱(); | ||
1920 | /// ❰ ❰ ❰ Vec ❱ ::<u8> ❱ ::with_capacity ❱(1024); | ||
1921 | /// ❰ ❰ <❰ Foo ❱ as ❰ ❰ bar ❱ ::Bar ❱> ❱ ::baz ❱(); | ||
1922 | /// ❰ ❰ <❰ bruh ❱> ❱ ::bruuh ❱(); | ||
1923 | /// ``` | ||
1924 | /// | ||
1925 | /// [Reference](https://doc.rust-lang.org/reference/paths.html) | ||
1926 | struct Path { | ||
1927 | segment: PathSegment, | ||
1928 | T![::], | ||
1929 | qualifier: Path, | ||
1930 | } | ||
1931 | |||
1932 | /// Segment of the path to a symbol. | ||
1933 | /// Only path segment of an absolute path holds the `::` token, | ||
1934 | /// all other `::` tokens that connect path segments reside under `Path` itself.` | ||
1935 | /// | ||
1936 | /// ``` | ||
1937 | /// (0..10).❰ collect ❱ :: ❰ <Vec<_>> ❱(); | ||
1938 | /// ❰ Vec ❱ :: ❰ <u8> ❱ :: ❰ with_capacity ❱(1024); | ||
1939 | /// ❰ <❰ Foo ❱ as ❰ bar ❱ :: ❰ Bar ❱> ❱ :: ❰ baz ❱(); | ||
1940 | /// ❰ <❰ bruh ❱> ❱ :: ❰ bruuh ❱(); | ||
1941 | /// | ||
1942 | /// // Note that only in this case `::` token is inlcuded: | ||
1943 | /// ❰ ::foo ❱; | ||
1944 | /// ``` | ||
1945 | /// | ||
1946 | /// [Reference](https://doc.rust-lang.org/reference/paths.html) | ||
1947 | struct PathSegment { | ||
1948 | T![::], T![crate], T![self], T![super], T![<], NameRef, TypeArgList, ParamList, RetType, PathType, T![>] | ||
1949 | } | ||
1950 | |||
1951 | /// List of type arguments that are passed at generic instantiation site. | ||
1952 | /// | ||
1953 | /// ``` | ||
1954 | /// type _ = Foo ❰ ::<'a, u64, Item = Bar, 42, {true}> ❱::Bar; | ||
1955 | /// | ||
1956 | /// Vec❰ ::<bool> ❱::(); | ||
1957 | /// ``` | ||
1958 | /// | ||
1959 | /// [Reference](https://doc.rust-lang.org/reference/paths.html#paths-in-expressions) | ||
1960 | struct TypeArgList { | ||
1961 | T![::], | ||
1962 | T![<], | ||
1963 | generic_args: [GenericArg], | ||
1964 | type_args: [TypeArg], | ||
1965 | lifetime_args: [LifetimeArg], | ||
1966 | assoc_type_args: [AssocTypeArg], | ||
1967 | const_args: [ConstArg], | ||
1968 | T![>] | ||
1969 | } | ||
1970 | |||
1971 | /// Type argument that is passed at generic instantiation site. | ||
1972 | /// | ||
1973 | /// ``` | ||
1974 | /// type _ = Foo::<'a, ❰ u64 ❱, ❰ bool ❱, Item = Bar, 42>::Baz; | ||
1975 | /// ``` | ||
1976 | /// | ||
1977 | /// [Reference](https://doc.rust-lang.org/reference/paths.html#paths-in-expressions) | ||
1978 | struct TypeArg { TypeRef } | ||
1979 | |||
1980 | /// Associated type argument that is passed at generic instantiation site. | ||
1981 | /// ``` | ||
1982 | /// type Foo = Bar::<'a, u64, bool, ❰ Item = Baz ❱, 42>::Bruh; | ||
1983 | /// | ||
1984 | /// trait Bruh<T>: Iterator<❰ Item: Debug ❱> {} | ||
1985 | /// ``` | ||
1986 | /// | ||
1987 | struct AssocTypeArg : TypeBoundsOwner { NameRef, T![=], TypeRef } | ||
1988 | |||
1989 | /// Lifetime argument that is passed at generic instantiation site. | ||
1990 | /// | ||
1991 | /// ``` | ||
1992 | /// fn foo<'a>(s: &'a str) { | ||
1993 | /// bar::<❰ 'a ❱>(s); | ||
1994 | /// } | ||
1995 | /// ``` | ||
1996 | /// | ||
1997 | /// [Reference](https://doc.rust-lang.org/reference/paths.html#paths-in-expressions) | ||
1998 | struct LifetimeArg { T![lifetime] } | ||
1999 | |||
2000 | /// Constant value argument that is passed at generic instantiation site. | ||
2001 | /// | ||
2002 | /// ``` | ||
2003 | /// foo::<u32, ❰ { true } ❱>(); | ||
2004 | /// | ||
2005 | /// bar::<❰ { 2 + 2} ❱>(); | ||
2006 | /// ``` | ||
2007 | /// | ||
2008 | /// [RFC](https://github.com/rust-lang/rfcs/blob/master/text/2000-const-generics.md#declaring-a-const-parameter) | ||
2009 | struct ConstArg { Literal, BlockExpr } | ||
2010 | |||
2011 | |||
2012 | /// FIXME: (@edwin0cheng) Remove it to use ItemList instead | ||
2013 | /// https://github.com/rust-analyzer/rust-analyzer/pull/4083#discussion_r422666243 | ||
2014 | /// | ||
2015 | /// [Reference](https://doc.rust-lang.org/reference/macros.html) | ||
2016 | struct MacroItems: ModuleItemOwner { } | ||
2017 | |||
2018 | /// FIXME: (@edwin0cheng) add some documentation here. As per the writing | ||
2019 | /// of this comment this ast node is not used. | ||
2020 | /// | ||
2021 | /// ``` | ||
2022 | /// // FIXME: example here | ||
2023 | /// ``` | ||
2024 | /// | ||
2025 | /// [Reference](https://doc.rust-lang.org/reference/macros.html) | ||
2026 | struct MacroStmts { | ||
2027 | statements: [Stmt], | ||
2028 | Expr, | ||
2029 | } | ||
2030 | |||
2031 | /// List of items in an extern block. | ||
2032 | /// | ||
2033 | /// ``` | ||
2034 | /// extern "C" ❰ | ||
2035 | /// { | ||
2036 | /// fn foo(); | ||
2037 | /// static var: u32; | ||
2038 | /// } | ||
2039 | /// ❱ | ||
2040 | /// ``` | ||
2041 | /// | ||
2042 | /// [Reference](https://doc.rust-lang.org/reference/items/external-blocks.html) | ||
2043 | struct ExternItemList: ModuleItemOwner { | ||
2044 | T!['{'], | ||
2045 | extern_items: [ExternItem], | ||
2046 | T!['}'] | ||
2047 | } | ||
2048 | |||
2049 | /// Extern block. | ||
2050 | /// | ||
2051 | /// ``` | ||
2052 | /// ❰ | ||
2053 | /// extern "C" { | ||
2054 | /// fn foo(); | ||
2055 | /// } | ||
2056 | /// ❱ | ||
2057 | /// | ||
2058 | /// ``` | ||
2059 | /// | ||
2060 | /// [Reference](https://doc.rust-lang.org/reference/items/external-blocks.html) | ||
2061 | struct ExternBlock { | ||
2062 | Abi, | ||
2063 | ExternItemList | ||
2064 | } | ||
2065 | |||
2066 | /// Meta item in an attribute. | ||
2067 | /// | ||
2068 | /// ``` | ||
2069 | /// #[❰ bar::baz = "42" ❱] | ||
2070 | /// #[❰ bruh(bruuh("true")) ❱] | ||
2071 | /// struct Foo; | ||
2072 | /// ``` | ||
2073 | /// | ||
2074 | /// [Reference](https://doc.rust-lang.org/reference/attributes.html?highlight=meta,item#meta-item-attribute-syntax) | ||
2075 | struct MetaItem { | ||
2076 | Path, T![=], AttrInput, nested_meta_items: [MetaItem] | ||
2077 | } | ||
2078 | |||
2079 | /// Macro 2.0 definition. | ||
2080 | /// Their syntax is still WIP by rustc team... | ||
2081 | /// ``` | ||
2082 | /// ❰ | ||
2083 | /// macro foo { } | ||
2084 | /// ❱ | ||
2085 | /// ``` | ||
2086 | /// | ||
2087 | /// [RFC](https://github.com/rust-lang/rfcs/blob/master/text/1584-macros.md) | ||
2088 | struct MacroDef { | ||
2089 | Name, TokenTree | ||
2090 | } | ||
2091 | }, | ||
2092 | enums: &ast_enums! { | ||
2093 | /// Any kind of nominal type definition. | ||
2094 | enum NominalDef: NameOwner, TypeParamsOwner, AttrsOwner { | ||
2095 | StructDef, EnumDef, UnionDef, | ||
2096 | } | ||
2097 | |||
2098 | /// Any kind of **declared** generic parameter | ||
2099 | enum GenericParam { | ||
2100 | LifetimeParam, | ||
2101 | TypeParam, | ||
2102 | ConstParam | ||
2103 | } | ||
2104 | |||
2105 | /// Any kind of generic argument passed at instantiation site | ||
2106 | enum GenericArg { | ||
2107 | LifetimeArg, | ||
2108 | TypeArg, | ||
2109 | ConstArg, | ||
2110 | AssocTypeArg | ||
2111 | } | ||
2112 | |||
2113 | /// Any kind of construct valid in type context | ||
2114 | enum TypeRef { | ||
2115 | ParenType, | ||
2116 | TupleType, | ||
2117 | NeverType, | ||
2118 | PathType, | ||
2119 | PointerType, | ||
2120 | ArrayType, | ||
2121 | SliceType, | ||
2122 | ReferenceType, | ||
2123 | PlaceholderType, | ||
2124 | FnPointerType, | ||
2125 | ForType, | ||
2126 | ImplTraitType, | ||
2127 | DynTraitType, | ||
2128 | } | ||
2129 | |||
2130 | /// Any kind of top-level item that may appear in a module | ||
2131 | enum ModuleItem: NameOwner, AttrsOwner, VisibilityOwner { | ||
2132 | StructDef, | ||
2133 | UnionDef, | ||
2134 | EnumDef, | ||
2135 | FnDef, | ||
2136 | TraitDef, | ||
2137 | TypeAliasDef, | ||
2138 | ImplDef, | ||
2139 | UseItem, | ||
2140 | ExternCrateItem, | ||
2141 | ConstDef, | ||
2142 | StaticDef, | ||
2143 | Module, | ||
2144 | MacroCall, | ||
2145 | ExternBlock | ||
2146 | } | ||
2147 | |||
2148 | |||
2149 | |||
2150 | /// Any kind of item that may appear in an impl block | ||
2151 | /// | ||
2152 | /// // FIXME: impl blocks can also contain MacroCall | ||
2153 | enum AssocItem: NameOwner, AttrsOwner { | ||
2154 | FnDef, TypeAliasDef, ConstDef | ||
2155 | } | ||
2156 | |||
2157 | /// Any kind of item that may appear in an extern block | ||
2158 | /// | ||
2159 | /// // FIXME: extern blocks can also contain MacroCall | ||
2160 | enum ExternItem: NameOwner, AttrsOwner, VisibilityOwner { | ||
2161 | FnDef, StaticDef | ||
2162 | } | ||
2163 | |||
2164 | /// Any kind of expression | ||
2165 | enum Expr: AttrsOwner { | ||
2166 | TupleExpr, | ||
2167 | ArrayExpr, | ||
2168 | ParenExpr, | ||
2169 | PathExpr, | ||
2170 | LambdaExpr, | ||
2171 | IfExpr, | ||
2172 | LoopExpr, | ||
2173 | ForExpr, | ||
2174 | WhileExpr, | ||
2175 | ContinueExpr, | ||
2176 | BreakExpr, | ||
2177 | Label, | ||
2178 | BlockExpr, | ||
2179 | ReturnExpr, | ||
2180 | MatchExpr, | ||
2181 | RecordLit, | ||
2182 | CallExpr, | ||
2183 | IndexExpr, | ||
2184 | MethodCallExpr, | ||
2185 | FieldExpr, | ||
2186 | AwaitExpr, | ||
2187 | TryExpr, | ||
2188 | EffectExpr, | ||
2189 | CastExpr, | ||
2190 | RefExpr, | ||
2191 | PrefixExpr, | ||
2192 | RangeExpr, | ||
2193 | BinExpr, | ||
2194 | Literal, | ||
2195 | MacroCall, | ||
2196 | BoxExpr, | ||
2197 | } | ||
2198 | |||
2199 | /// Any kind of pattern | ||
2200 | enum Pat { | ||
2201 | OrPat, | ||
2202 | ParenPat, | ||
2203 | RefPat, | ||
2204 | BoxPat, | ||
2205 | BindPat, | ||
2206 | PlaceholderPat, | ||
2207 | DotDotPat, | ||
2208 | PathPat, | ||
2209 | RecordPat, | ||
2210 | TupleStructPat, | ||
2211 | TuplePat, | ||
2212 | SlicePat, | ||
2213 | RangePat, | ||
2214 | LiteralPat, | ||
2215 | MacroPat, | ||
2216 | } | ||
2217 | |||
2218 | /// Any kind of pattern that appears directly inside of the curly | ||
2219 | /// braces of a record pattern | ||
2220 | enum RecordInnerPat { | ||
2221 | RecordFieldPat, | ||
2222 | BindPat | ||
2223 | } | ||
2224 | |||
2225 | /// Any kind of input to an attribute | ||
2226 | enum AttrInput { Literal, TokenTree } | ||
2227 | |||
2228 | /// Any kind of statement | ||
2229 | /// Note: there are no empty statements, these are just represented as | ||
2230 | /// bare semicolons without a dedicated statement ast node. | ||
2231 | enum Stmt { | ||
2232 | LetStmt, | ||
2233 | ExprStmt, | ||
2234 | // macro calls are parsed as expression statements | ||
2235 | } | ||
2236 | |||
2237 | /// Any kind of fields list (record or tuple field lists) | ||
2238 | enum FieldDefList { | ||
2239 | RecordFieldDefList, | ||
2240 | TupleFieldDefList, | ||
2241 | } | ||
2242 | }, | ||
2243 | }; | ||