aboutsummaryrefslogtreecommitdiff
path: root/crates/ra_syntax/src
diff options
context:
space:
mode:
Diffstat (limited to 'crates/ra_syntax/src')
-rw-r--r--crates/ra_syntax/src/ast/generated/nodes.rs1504
1 files changed, 1366 insertions, 138 deletions
diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs
index b00c15608..cf6067e57 100644
--- a/crates/ra_syntax/src/ast/generated/nodes.rs
+++ b/crates/ra_syntax/src/ast/generated/nodes.rs
@@ -5,7 +5,9 @@ use crate::{
5 SyntaxKind::{self, *}, 5 SyntaxKind::{self, *},
6 SyntaxNode, SyntaxToken, T, 6 SyntaxNode, SyntaxToken, T,
7}; 7};
8 8/// The entire Rust source file. Includes all top-level inner attributes and module items.
9///
10/// [Reference](https://doc.rust-lang.org/reference/crates-and-source-files.html)
9#[derive(Debug, Clone, PartialEq, Eq, Hash)] 11#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10pub struct SourceFile { 12pub struct SourceFile {
11 pub(crate) syntax: SyntaxNode, 13 pub(crate) syntax: SyntaxNode,
@@ -16,7 +18,28 @@ impl ast::DocCommentsOwner for SourceFile {}
16impl SourceFile { 18impl SourceFile {
17 pub fn modules(&self) -> AstChildren<Module> { support::children(&self.syntax) } 19 pub fn modules(&self) -> AstChildren<Module> { support::children(&self.syntax) }
18} 20}
19 21/// Function definition either with body or not.
22/// Includes all of its attributes and doc comments.
23///
24/// ```
25/// ❰
26/// /// Docs
27/// #[attr]
28/// pub extern "C" fn foo<T>(#[attr] Patern {p}: Pattern) -> u32
29/// where
30/// T: Debug
31/// {
32/// 42
33/// }
34/// ❱
35///
36/// extern "C" {
37/// ❰ fn fn_decl(also_variadic_ffi: u32, ...) -> u32; ❱
38/// }
39/// ```
40///
41/// - [Reference](https://doc.rust-lang.org/reference/items/functions.html)
42/// - [Nomicon](https://doc.rust-lang.org/nomicon/ffi.html#variadic-functions)
20#[derive(Debug, Clone, PartialEq, Eq, Hash)] 43#[derive(Debug, Clone, PartialEq, Eq, Hash)]
21pub struct FnDef { 44pub struct FnDef {
22 pub(crate) syntax: SyntaxNode, 45 pub(crate) syntax: SyntaxNode,
@@ -38,7 +61,13 @@ impl FnDef {
38 pub fn body(&self) -> Option<BlockExpr> { support::child(&self.syntax) } 61 pub fn body(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
39 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } 62 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
40} 63}
41 64/// Return type annotation.
65///
66/// ```
67/// fn foo(a: u32) ❰ -> Option<u32> ❱ { Some(a) }
68/// ```
69///
70/// [Reference](https://doc.rust-lang.org/reference/items/functions.html)
42#[derive(Debug, Clone, PartialEq, Eq, Hash)] 71#[derive(Debug, Clone, PartialEq, Eq, Hash)]
43pub struct RetType { 72pub struct RetType {
44 pub(crate) syntax: SyntaxNode, 73 pub(crate) syntax: SyntaxNode,
@@ -47,7 +76,26 @@ impl RetType {
47 pub fn thin_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![->]) } 76 pub fn thin_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![->]) }
48 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 77 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
49} 78}
50 79/// Struct definition.
80/// Includes all of its attributes and doc comments.
81///
82/// ```
83/// ❰
84/// /// Docs
85/// #[attr]
86/// struct Foo<T> where T: Debug {
87/// /// Docs
88/// #[attr]
89/// pub a: u32,
90/// b: T,
91/// }
92/// ❱
93///
94/// ❰ struct Foo; ❱
95/// ❰ struct Foo<T>(#[attr] T) where T: Debug; ❱
96/// ```
97///
98/// [Reference](https://doc.rust-lang.org/reference/items/structs.html)
51#[derive(Debug, Clone, PartialEq, Eq, Hash)] 99#[derive(Debug, Clone, PartialEq, Eq, Hash)]
52pub struct StructDef { 100pub struct StructDef {
53 pub(crate) syntax: SyntaxNode, 101 pub(crate) syntax: SyntaxNode,
@@ -62,7 +110,23 @@ impl StructDef {
62 pub fn field_def_list(&self) -> Option<FieldDefList> { support::child(&self.syntax) } 110 pub fn field_def_list(&self) -> Option<FieldDefList> { support::child(&self.syntax) }
63 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } 111 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
64} 112}
65 113/// Union definition.
114/// Includes all of its attributes and doc comments.
115///
116/// ```
117/// ❰
118/// /// Docs
119/// #[attr]
120/// pub union Foo<T> where T: Debug {
121/// /// Docs
122/// #[attr]
123/// a: T,
124/// b: u32,
125/// }
126/// ❱
127/// ```
128///
129/// [Reference](https://doc.rust-lang.org/reference/items/unions.html)
66#[derive(Debug, Clone, PartialEq, Eq, Hash)] 130#[derive(Debug, Clone, PartialEq, Eq, Hash)]
67pub struct UnionDef { 131pub struct UnionDef {
68 pub(crate) syntax: SyntaxNode, 132 pub(crate) syntax: SyntaxNode,
@@ -78,7 +142,19 @@ impl UnionDef {
78 support::child(&self.syntax) 142 support::child(&self.syntax)
79 } 143 }
80} 144}
81 145/// Record field definition list including enclosing curly braces.
146///
147/// ```
148/// struct Foo // same for union
149/// ❰
150/// {
151/// a: u32,
152/// b: bool,
153/// }
154/// ❱
155/// ```
156///
157/// [Reference](https://doc.rust-lang.org/reference/items/structs.html)
82#[derive(Debug, Clone, PartialEq, Eq, Hash)] 158#[derive(Debug, Clone, PartialEq, Eq, Hash)]
83pub struct RecordFieldDefList { 159pub struct RecordFieldDefList {
84 pub(crate) syntax: SyntaxNode, 160 pub(crate) syntax: SyntaxNode,
@@ -88,7 +164,22 @@ impl RecordFieldDefList {
88 pub fn fields(&self) -> AstChildren<RecordFieldDef> { support::children(&self.syntax) } 164 pub fn fields(&self) -> AstChildren<RecordFieldDef> { support::children(&self.syntax) }
89 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } 165 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
90} 166}
91 167/// Record field definition including its attributes and doc comments.
168///
169/// ` ``
170/// same for union
171/// struct Foo {
172/// ❰
173/// /// Docs
174/// #[attr]
175/// pub a: u32
176/// ❱
177///
178/// ❰ b: bool ❱
179/// }
180/// ```
181///
182/// [Reference](https://doc.rust-lang.org/reference/items/structs.html)
92#[derive(Debug, Clone, PartialEq, Eq, Hash)] 183#[derive(Debug, Clone, PartialEq, Eq, Hash)]
93pub struct RecordFieldDef { 184pub struct RecordFieldDef {
94 pub(crate) syntax: SyntaxNode, 185 pub(crate) syntax: SyntaxNode,
@@ -99,7 +190,13 @@ impl ast::AttrsOwner for RecordFieldDef {}
99impl ast::DocCommentsOwner for RecordFieldDef {} 190impl ast::DocCommentsOwner for RecordFieldDef {}
100impl ast::TypeAscriptionOwner for RecordFieldDef {} 191impl ast::TypeAscriptionOwner for RecordFieldDef {}
101impl RecordFieldDef {} 192impl RecordFieldDef {}
102 193/// Tuple field definition list including enclosing parens.
194///
195/// ```
196/// struct Foo ❰ (u32, String, Vec<u32>) ❱;
197/// ```
198///
199/// [Reference](https://doc.rust-lang.org/reference/items/structs.html)
103#[derive(Debug, Clone, PartialEq, Eq, Hash)] 200#[derive(Debug, Clone, PartialEq, Eq, Hash)]
104pub struct TupleFieldDefList { 201pub struct TupleFieldDefList {
105 pub(crate) syntax: SyntaxNode, 202 pub(crate) syntax: SyntaxNode,
@@ -109,7 +206,13 @@ impl TupleFieldDefList {
109 pub fn fields(&self) -> AstChildren<TupleFieldDef> { support::children(&self.syntax) } 206 pub fn fields(&self) -> AstChildren<TupleFieldDef> { support::children(&self.syntax) }
110 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } 207 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
111} 208}
112 209/// Tuple field definition including its attributes.
210///
211/// ```
212/// struct Foo(❰ #[attr] u32 ❱);
213/// ```
214///
215/// [Reference](https://doc.rust-lang.org/reference/items/structs.html)
113#[derive(Debug, Clone, PartialEq, Eq, Hash)] 216#[derive(Debug, Clone, PartialEq, Eq, Hash)]
114pub struct TupleFieldDef { 217pub struct TupleFieldDef {
115 pub(crate) syntax: SyntaxNode, 218 pub(crate) syntax: SyntaxNode,
@@ -119,7 +222,29 @@ impl ast::AttrsOwner for TupleFieldDef {}
119impl TupleFieldDef { 222impl TupleFieldDef {
120 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 223 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
121} 224}
122 225/// Enum definition.
226/// Includes all of its attributes and doc comments.
227///
228/// ```
229/// ❰
230/// /// Docs
231/// #[attr]
232/// pub enum Foo<T> where T: Debug {
233/// /// Docs
234/// #[attr]
235/// Bar,
236/// Baz(#[attr] u32),
237/// Bruh {
238/// a: u32,
239/// /// Docs
240/// #[attr]
241/// b: T,
242/// }
243/// }
244/// ❱
245/// ```
246///
247/// [Reference](https://doc.rust-lang.org/reference/items/enumerations.html)
123#[derive(Debug, Clone, PartialEq, Eq, Hash)] 248#[derive(Debug, Clone, PartialEq, Eq, Hash)]
124pub struct EnumDef { 249pub struct EnumDef {
125 pub(crate) syntax: SyntaxNode, 250 pub(crate) syntax: SyntaxNode,
@@ -133,7 +258,22 @@ impl EnumDef {
133 pub fn enum_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![enum]) } 258 pub fn enum_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![enum]) }
134 pub fn variant_list(&self) -> Option<EnumVariantList> { support::child(&self.syntax) } 259 pub fn variant_list(&self) -> Option<EnumVariantList> { support::child(&self.syntax) }
135} 260}
136 261/// Enum variant definition list including enclosing curly braces.
262///
263/// ```
264/// enum Foo
265/// ❰
266/// {
267/// Bar,
268/// Baz(u32),
269/// Bruh {
270/// a: u32
271/// }
272/// }
273/// ❱
274/// ```
275///
276/// [Reference](https://doc.rust-lang.org/reference/items/enumerations.html)
137#[derive(Debug, Clone, PartialEq, Eq, Hash)] 277#[derive(Debug, Clone, PartialEq, Eq, Hash)]
138pub struct EnumVariantList { 278pub struct EnumVariantList {
139 pub(crate) syntax: SyntaxNode, 279 pub(crate) syntax: SyntaxNode,
@@ -143,7 +283,21 @@ impl EnumVariantList {
143 pub fn variants(&self) -> AstChildren<EnumVariant> { support::children(&self.syntax) } 283 pub fn variants(&self) -> AstChildren<EnumVariant> { support::children(&self.syntax) }
144 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } 284 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
145} 285}
146 286/// Enum variant definition including its attributes and discriminant value definition.
287///
288/// ```
289/// enum Foo {
290/// ❰
291/// /// Docs
292/// #[attr]
293/// Bar
294/// ❱
295///
296/// // same for tuple and record variants
297/// }
298/// ```
299///
300/// [Reference](https://doc.rust-lang.org/reference/items/enumerations.html)
147#[derive(Debug, Clone, PartialEq, Eq, Hash)] 301#[derive(Debug, Clone, PartialEq, Eq, Hash)]
148pub struct EnumVariant { 302pub struct EnumVariant {
149 pub(crate) syntax: SyntaxNode, 303 pub(crate) syntax: SyntaxNode,
@@ -157,7 +311,20 @@ impl EnumVariant {
157 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } 311 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
158 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 312 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
159} 313}
160 314/// Trait definition.
315/// Includes all of its attributes and doc comments.
316///
317/// ```
318/// ❰
319/// /// Docs
320/// #[attr]
321/// pub unsafe trait Foo<T>: Debug where T: Debug {
322/// // ...
323/// }
324/// ❱
325/// ```
326///
327/// [Reference](https://doc.rust-lang.org/reference/items/traits.html)
161#[derive(Debug, Clone, PartialEq, Eq, Hash)] 328#[derive(Debug, Clone, PartialEq, Eq, Hash)]
162pub struct TraitDef { 329pub struct TraitDef {
163 pub(crate) syntax: SyntaxNode, 330 pub(crate) syntax: SyntaxNode,
@@ -174,7 +341,27 @@ impl TraitDef {
174 pub fn trait_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![trait]) } 341 pub fn trait_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![trait]) }
175 pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) } 342 pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
176} 343}
177 344/// Module definition either with body or not.
345/// Includes all of its inner and outer attributes, module items, doc comments.
346///
347/// ```
348/// ❰
349/// /// Docs
350/// #[attr]
351/// pub mod foo;
352/// ❱
353///
354/// ❰
355/// /// Docs
356/// #[attr]
357/// pub mod bar {
358/// //! Inner docs
359/// #![inner_attr]
360/// }
361/// ❱
362/// ```
363///
364/// [Reference](https://doc.rust-lang.org/reference/items/modules.html)
178#[derive(Debug, Clone, PartialEq, Eq, Hash)] 365#[derive(Debug, Clone, PartialEq, Eq, Hash)]
179pub struct Module { 366pub struct Module {
180 pub(crate) syntax: SyntaxNode, 367 pub(crate) syntax: SyntaxNode,
@@ -188,7 +375,28 @@ impl Module {
188 pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) } 375 pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
189 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } 376 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
190} 377}
191 378/// Item defintion list.
379/// This is used for both top-level items and impl block items.
380///
381/// ```
382/// ❰
383/// fn foo {}
384/// struct Bar;
385/// enum Baz;
386/// trait Bruh;
387/// const BRUUH: u32 = 42;
388/// ❱
389///
390/// impl Foo
391/// ❰
392/// {
393/// fn bar() {}
394/// const BAZ: u32 = 42;
395/// }
396/// ❱
397/// ```
398///
399/// [Reference](https://doc.rust-lang.org/reference/items.html)
192#[derive(Debug, Clone, PartialEq, Eq, Hash)] 400#[derive(Debug, Clone, PartialEq, Eq, Hash)]
193pub struct ItemList { 401pub struct ItemList {
194 pub(crate) syntax: SyntaxNode, 402 pub(crate) syntax: SyntaxNode,
@@ -199,7 +407,18 @@ impl ItemList {
199 pub fn assoc_items(&self) -> AstChildren<AssocItem> { support::children(&self.syntax) } 407 pub fn assoc_items(&self) -> AstChildren<AssocItem> { support::children(&self.syntax) }
200 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } 408 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
201} 409}
202 410/// Constant variable definition.
411/// Includes all of its attributes and doc comments.
412///
413/// ```
414/// ❰
415/// /// Docs
416/// #[attr]
417/// pub const FOO: u32 = 42;
418/// ❱
419/// ```
420///
421/// [Reference](https://doc.rust-lang.org/reference/items/constant-items.html)
203#[derive(Debug, Clone, PartialEq, Eq, Hash)] 422#[derive(Debug, Clone, PartialEq, Eq, Hash)]
204pub struct ConstDef { 423pub struct ConstDef {
205 pub(crate) syntax: SyntaxNode, 424 pub(crate) syntax: SyntaxNode,
@@ -217,7 +436,18 @@ impl ConstDef {
217 pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) } 436 pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
218 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } 437 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
219} 438}
220 439/// Static variable definition.
440/// Includes all of its attributes and doc comments.
441///
442/// ```
443/// ❰
444/// /// Docs
445/// #[attr]
446/// pub static mut FOO: u32 = 42;
447/// ❱
448/// ```
449///
450/// [Reference](https://doc.rust-lang.org/reference/items/static-items.html)
221#[derive(Debug, Clone, PartialEq, Eq, Hash)] 451#[derive(Debug, Clone, PartialEq, Eq, Hash)]
222pub struct StaticDef { 452pub struct StaticDef {
223 pub(crate) syntax: SyntaxNode, 453 pub(crate) syntax: SyntaxNode,
@@ -235,7 +465,24 @@ impl StaticDef {
235 pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) } 465 pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
236 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } 466 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
237} 467}
238 468/// Type alias definition.
469/// Includes associated type clauses with type bounds.
470///
471/// ```
472/// ❰
473/// /// Docs
474/// #[attr]
475/// pub type Foo<T> where T: Debug = T;
476/// ❱
477///
478/// trait Bar {
479/// ❰ type Baz: Debug; ❱
480/// ❰ type Bruh = String; ❱
481/// ❰ type Bruuh: Debug = u32; ❱
482/// }
483/// ```
484///
485/// [Reference](https://doc.rust-lang.org/reference/items/type-aliases.html)
239#[derive(Debug, Clone, PartialEq, Eq, Hash)] 486#[derive(Debug, Clone, PartialEq, Eq, Hash)]
240pub struct TypeAliasDef { 487pub struct TypeAliasDef {
241 pub(crate) syntax: SyntaxNode, 488 pub(crate) syntax: SyntaxNode,
@@ -253,7 +500,20 @@ impl TypeAliasDef {
253 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 500 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
254 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } 501 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
255} 502}
256 503/// Inherent and trait impl definition.
504/// Includes all of its inner and outer attributes.
505///
506/// ```
507/// ❰
508/// #[attr]
509/// unsafe impl<T> const !Foo for Bar where T: Debug {
510/// #![inner_attr]
511/// // ...
512/// }
513/// ❱
514/// ```
515///
516/// [Reference](https://doc.rust-lang.org/reference/items/implementations.html)
257#[derive(Debug, Clone, PartialEq, Eq, Hash)] 517#[derive(Debug, Clone, PartialEq, Eq, Hash)]
258pub struct ImplDef { 518pub struct ImplDef {
259 pub(crate) syntax: SyntaxNode, 519 pub(crate) syntax: SyntaxNode,
@@ -270,7 +530,16 @@ impl ImplDef {
270 pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) } 530 pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
271 pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) } 531 pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) }
272} 532}
273 533/// Parenthesized type reference.
534/// Note: parens are only used for grouping, this is not a tuple type.
535///
536/// ```
537/// // This is effectively just `u32`.
538/// // Single-item tuple must be defined with a trailing comma: `(u32,)`
539/// type Foo = ❰ (u32) ❱;
540///
541/// let bar: &'static ❰ (dyn Debug) ❱ = "bruh";
542/// ```
274#[derive(Debug, Clone, PartialEq, Eq, Hash)] 543#[derive(Debug, Clone, PartialEq, Eq, Hash)]
275pub struct ParenType { 544pub struct ParenType {
276 pub(crate) syntax: SyntaxNode, 545 pub(crate) syntax: SyntaxNode,
@@ -280,7 +549,13 @@ impl ParenType {
280 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 549 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
281 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } 550 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
282} 551}
283 552/// Unnamed tuple type.
553///
554/// ```
555/// let foo: ❰ (u32, bool) ❱ = (42, true);
556/// ```
557///
558/// [Reference](https://doc.rust-lang.org/reference/types/tuple.html)
284#[derive(Debug, Clone, PartialEq, Eq, Hash)] 559#[derive(Debug, Clone, PartialEq, Eq, Hash)]
285pub struct TupleType { 560pub struct TupleType {
286 pub(crate) syntax: SyntaxNode, 561 pub(crate) syntax: SyntaxNode,
@@ -290,7 +565,17 @@ impl TupleType {
290 pub fn fields(&self) -> AstChildren<TypeRef> { support::children(&self.syntax) } 565 pub fn fields(&self) -> AstChildren<TypeRef> { support::children(&self.syntax) }
291 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } 566 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
292} 567}
293 568/// The never type (i.e. the exclamation point).
569///
570/// ```
571/// type T = ❰ ! ❱;
572///
573/// fn no_return() -> ❰ ! ❱ {
574/// loop {}
575/// }
576/// ```
577///
578/// [Reference](https://doc.rust-lang.org/reference/types/never.html)
294#[derive(Debug, Clone, PartialEq, Eq, Hash)] 579#[derive(Debug, Clone, PartialEq, Eq, Hash)]
295pub struct NeverType { 580pub struct NeverType {
296 pub(crate) syntax: SyntaxNode, 581 pub(crate) syntax: SyntaxNode,
@@ -298,7 +583,17 @@ pub struct NeverType {
298impl NeverType { 583impl NeverType {
299 pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) } 584 pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
300} 585}
301 586/// Path to a type.
587/// Includes single identifier type names and elaborate paths with
588/// generic parameters.
589///
590/// ```
591/// type Foo = ❰ String ❱;
592/// type Bar = ❰ std::vec::Vec<T> ❱;
593/// type Baz = ❰ ::bruh::<Bruuh as Iterator>::Item ❱;
594/// ```
595///
596/// [Reference](https://doc.rust-lang.org/reference/paths.html)
302#[derive(Debug, Clone, PartialEq, Eq, Hash)] 597#[derive(Debug, Clone, PartialEq, Eq, Hash)]
303pub struct PathType { 598pub struct PathType {
304 pub(crate) syntax: SyntaxNode, 599 pub(crate) syntax: SyntaxNode,
@@ -306,7 +601,14 @@ pub struct PathType {
306impl PathType { 601impl PathType {
307 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } 602 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
308} 603}
309 604/// Raw pointer type.
605///
606/// ```
607/// type Foo = ❰ *const u32 ❱;
608/// type Bar = ❰ *mut u32 ❱;
609/// ```
610///
611/// [Reference](https://doc.rust-lang.org/reference/types/pointer.html#raw-pointers-const-and-mut)
310#[derive(Debug, Clone, PartialEq, Eq, Hash)] 612#[derive(Debug, Clone, PartialEq, Eq, Hash)]
311pub struct PointerType { 613pub struct PointerType {
312 pub(crate) syntax: SyntaxNode, 614 pub(crate) syntax: SyntaxNode,
@@ -317,7 +619,13 @@ impl PointerType {
317 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } 619 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
318 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 620 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
319} 621}
320 622/// Array type.
623///
624/// ```
625/// type Foo = ❰ [u32; 24 - 3] ❱;
626/// ```
627///
628/// [Reference](https://doc.rust-lang.org/reference/types/array.html)
321#[derive(Debug, Clone, PartialEq, Eq, Hash)] 629#[derive(Debug, Clone, PartialEq, Eq, Hash)]
322pub struct ArrayType { 630pub struct ArrayType {
323 pub(crate) syntax: SyntaxNode, 631 pub(crate) syntax: SyntaxNode,
@@ -329,7 +637,13 @@ impl ArrayType {
329 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 637 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
330 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } 638 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
331} 639}
332 640/// Slice type.
641///
642/// ```
643/// type Foo = ❰ [u8] ❱;
644/// ```
645///
646/// [Reference](https://doc.rust-lang.org/reference/types/slice.html)
333#[derive(Debug, Clone, PartialEq, Eq, Hash)] 647#[derive(Debug, Clone, PartialEq, Eq, Hash)]
334pub struct SliceType { 648pub struct SliceType {
335 pub(crate) syntax: SyntaxNode, 649 pub(crate) syntax: SyntaxNode,
@@ -339,7 +653,13 @@ impl SliceType {
339 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 653 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
340 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } 654 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
341} 655}
342 656/// Reference type.
657///
658/// ```
659/// type Foo = ❰ &'static str ❱;
660/// ```
661///
662/// [Reference](https://doc.rust-lang.org/reference/types/pointer.html)
343#[derive(Debug, Clone, PartialEq, Eq, Hash)] 663#[derive(Debug, Clone, PartialEq, Eq, Hash)]
344pub struct ReferenceType { 664pub struct ReferenceType {
345 pub(crate) syntax: SyntaxNode, 665 pub(crate) syntax: SyntaxNode,
@@ -352,7 +672,13 @@ impl ReferenceType {
352 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } 672 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
353 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 673 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
354} 674}
355 675/// Placeholder type (i.e. the underscore).
676///
677/// ```
678/// let foo: ❰ _ ❱ = 42_u32;
679/// ```
680///
681/// [Reference](https://doc.rust-lang.org/reference/types/inferred.html)
356#[derive(Debug, Clone, PartialEq, Eq, Hash)] 682#[derive(Debug, Clone, PartialEq, Eq, Hash)]
357pub struct PlaceholderType { 683pub struct PlaceholderType {
358 pub(crate) syntax: SyntaxNode, 684 pub(crate) syntax: SyntaxNode,
@@ -360,7 +686,15 @@ pub struct PlaceholderType {
360impl PlaceholderType { 686impl PlaceholderType {
361 pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) } 687 pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
362} 688}
363 689/// Function pointer type (not to be confused with `Fn*` family of traits).
690///
691/// ```
692/// type Foo = ❰ async fn(#[attr] u32, named: bool) -> u32 ❱;
693///
694/// type Bar = ❰ extern "C" fn(variadic: u32, #[attr] ...) ❱;
695/// ```
696///
697/// [Reference](https://doc.rust-lang.org/reference/types/function-pointer.html)
364#[derive(Debug, Clone, PartialEq, Eq, Hash)] 698#[derive(Debug, Clone, PartialEq, Eq, Hash)]
365pub struct FnPointerType { 699pub struct FnPointerType {
366 pub(crate) syntax: SyntaxNode, 700 pub(crate) syntax: SyntaxNode,
@@ -372,7 +706,13 @@ impl FnPointerType {
372 pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) } 706 pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) }
373 pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } 707 pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
374} 708}
375 709/// Higher order type.
710///
711/// ```
712/// type Foo = ❰ for<'a> fn(&'a str) ❱;
713/// ```
714///
715/// [Reference](https://doc.rust-lang.org/nomicon/hrtb.html)
376#[derive(Debug, Clone, PartialEq, Eq, Hash)] 716#[derive(Debug, Clone, PartialEq, Eq, Hash)]
377pub struct ForType { 717pub struct ForType {
378 pub(crate) syntax: SyntaxNode, 718 pub(crate) syntax: SyntaxNode,
@@ -382,7 +722,13 @@ impl ForType {
382 pub fn type_param_list(&self) -> Option<TypeParamList> { support::child(&self.syntax) } 722 pub fn type_param_list(&self) -> Option<TypeParamList> { support::child(&self.syntax) }
383 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 723 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
384} 724}
385 725/// Opaque `impl Trait` type.
726///
727/// ```
728/// fn foo(bar: ❰ impl Debug + Eq ❱) {}
729/// ```
730///
731/// [Reference](https://doc.rust-lang.org/reference/types/impl-trait.html)
386#[derive(Debug, Clone, PartialEq, Eq, Hash)] 732#[derive(Debug, Clone, PartialEq, Eq, Hash)]
387pub struct ImplTraitType { 733pub struct ImplTraitType {
388 pub(crate) syntax: SyntaxNode, 734 pub(crate) syntax: SyntaxNode,
@@ -391,7 +737,13 @@ impl ast::TypeBoundsOwner for ImplTraitType {}
391impl ImplTraitType { 737impl ImplTraitType {
392 pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) } 738 pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) }
393} 739}
394 740/// Trait object type.
741///
742/// ```
743/// type Foo = ❰ dyn Debug ❱;
744/// ```
745///
746/// [Reference](https://doc.rust-lang.org/reference/types/trait-object.html)
395#[derive(Debug, Clone, PartialEq, Eq, Hash)] 747#[derive(Debug, Clone, PartialEq, Eq, Hash)]
396pub struct DynTraitType { 748pub struct DynTraitType {
397 pub(crate) syntax: SyntaxNode, 749 pub(crate) syntax: SyntaxNode,
@@ -400,7 +752,13 @@ impl ast::TypeBoundsOwner for DynTraitType {}
400impl DynTraitType { 752impl DynTraitType {
401 pub fn dyn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![dyn]) } 753 pub fn dyn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![dyn]) }
402} 754}
403 755/// Tuple literal.
756///
757/// ```
758/// ❰ (42, true) ❱;
759/// ```
760///
761/// [Reference](https://doc.rust-lang.org/reference/expressions/tuple-expr.html)
404#[derive(Debug, Clone, PartialEq, Eq, Hash)] 762#[derive(Debug, Clone, PartialEq, Eq, Hash)]
405pub struct TupleExpr { 763pub struct TupleExpr {
406 pub(crate) syntax: SyntaxNode, 764 pub(crate) syntax: SyntaxNode,
@@ -411,7 +769,15 @@ impl TupleExpr {
411 pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) } 769 pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
412 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } 770 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
413} 771}
414 772/// Array literal.
773///
774/// ```
775/// ❰ [#![inner_attr] true, false, true] ❱;
776///
777/// ❰ ["baz"; 24] ❱;
778/// ```
779///
780/// [Reference](https://doc.rust-lang.org/reference/expressions/array-expr.html)
415#[derive(Debug, Clone, PartialEq, Eq, Hash)] 781#[derive(Debug, Clone, PartialEq, Eq, Hash)]
416pub struct ArrayExpr { 782pub struct ArrayExpr {
417 pub(crate) syntax: SyntaxNode, 783 pub(crate) syntax: SyntaxNode,
@@ -423,7 +789,14 @@ impl ArrayExpr {
423 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } 789 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
424 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } 790 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
425} 791}
426 792/// Parenthesized expression.
793/// Note: parens are only used for grouping, this is not a tuple literal.
794///
795/// ```
796/// ❰ (#![inner_attr] 2 + 2) ❱ * 2;
797/// ```
798///
799/// [Reference](https://doc.rust-lang.org/reference/expressions/grouped-expr.html)
427#[derive(Debug, Clone, PartialEq, Eq, Hash)] 800#[derive(Debug, Clone, PartialEq, Eq, Hash)]
428pub struct ParenExpr { 801pub struct ParenExpr {
429 pub(crate) syntax: SyntaxNode, 802 pub(crate) syntax: SyntaxNode,
@@ -434,7 +807,19 @@ impl ParenExpr {
434 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 807 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
435 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } 808 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
436} 809}
437 810/// Path to a symbol in expression context.
811/// Includes single identifier variable names and elaborate paths with
812/// generic parameters.
813///
814/// ```
815/// ❰ Some::<i32> ❱;
816/// ❰ foo ❱ + 42;
817/// ❰ Vec::<i32>::push ❱;
818/// ❰ <[i32]>::reverse ❱;
819/// ❰ <String as std::borrow::Borrow<str>>::borrow ❱;
820/// ```
821///
822/// [Reference](https://doc.rust-lang.org/reference/expressions/path-expr.html)
438#[derive(Debug, Clone, PartialEq, Eq, Hash)] 823#[derive(Debug, Clone, PartialEq, Eq, Hash)]
439pub struct PathExpr { 824pub struct PathExpr {
440 pub(crate) syntax: SyntaxNode, 825 pub(crate) syntax: SyntaxNode,
@@ -442,7 +827,17 @@ pub struct PathExpr {
442impl PathExpr { 827impl PathExpr {
443 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } 828 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
444} 829}
445 830/// Anonymous callable object literal a.k.a. closure, lambda or functor.
831///
832/// ```
833/// ❰ || 42 ❱;
834/// ❰ |a: u32| val + 1 ❱;
835/// ❰ async |#[attr] Pattern(_): Pattern| { bar } ❱;
836/// ❰ move || baz ❱;
837/// ❰ || -> u32 { closure_with_ret_type_annotation_requires_block_expr } ❱
838/// ```
839///
840/// [Reference](https://doc.rust-lang.org/reference/expressions/closure-expr.html)
446#[derive(Debug, Clone, PartialEq, Eq, Hash)] 841#[derive(Debug, Clone, PartialEq, Eq, Hash)]
447pub struct LambdaExpr { 842pub struct LambdaExpr {
448 pub(crate) syntax: SyntaxNode, 843 pub(crate) syntax: SyntaxNode,
@@ -456,7 +851,25 @@ impl LambdaExpr {
456 pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } 851 pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) }
457 pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) } 852 pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
458} 853}
459 854/// If expression. Includes both regular `if` and `if let` forms.
855/// Beware that `else if` is a special case syntax sugar, because in general
856/// there has to be block expression after `else`.
857///
858/// ```
859/// ❰ if bool_cond { 42 } ❱
860/// ❰ if bool_cond { 42 } else { 24 } ❱
861/// ❰ if bool_cond { 42 } else if bool_cond2 { 42 } ❱
862///
863/// ❰
864/// if let Pattern(foo) = bar {
865/// foo
866/// } else {
867/// panic!();
868/// }
869/// ❱
870/// ```
871///
872/// [Reference](https://doc.rust-lang.org/reference/expressions/if-expr.html)
460#[derive(Debug, Clone, PartialEq, Eq, Hash)] 873#[derive(Debug, Clone, PartialEq, Eq, Hash)]
461pub struct IfExpr { 874pub struct IfExpr {
462 pub(crate) syntax: SyntaxNode, 875 pub(crate) syntax: SyntaxNode,
@@ -466,7 +879,17 @@ impl IfExpr {
466 pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) } 879 pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }
467 pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) } 880 pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) }
468} 881}
469 882/// Unconditional loop expression.
883///
884/// ```
885/// ❰
886/// loop {
887/// // yeah, it's that simple...
888/// }
889/// ❱
890/// ```
891///
892/// [Reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html)
470#[derive(Debug, Clone, PartialEq, Eq, Hash)] 893#[derive(Debug, Clone, PartialEq, Eq, Hash)]
471pub struct LoopExpr { 894pub struct LoopExpr {
472 pub(crate) syntax: SyntaxNode, 895 pub(crate) syntax: SyntaxNode,
@@ -476,7 +899,20 @@ impl ast::LoopBodyOwner for LoopExpr {}
476impl LoopExpr { 899impl LoopExpr {
477 pub fn loop_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![loop]) } 900 pub fn loop_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![loop]) }
478} 901}
479 902/// Block expression with an optional prefix (label, try ketword,
903/// unsafe keyword, async keyword...).
904///
905/// ```
906/// ❰
907/// 'label: try {
908/// None?
909/// }
910/// ❱
911/// ```
912///
913/// - [try block](https://doc.rust-lang.org/unstable-book/language-features/try-blocks.html)
914/// - [unsafe block](https://doc.rust-lang.org/reference/expressions/block-expr.html#unsafe-blocks)
915/// - [async block](https://doc.rust-lang.org/reference/expressions/block-expr.html#async-blocks)
480#[derive(Debug, Clone, PartialEq, Eq, Hash)] 916#[derive(Debug, Clone, PartialEq, Eq, Hash)]
481pub struct EffectExpr { 917pub struct EffectExpr {
482 pub(crate) syntax: SyntaxNode, 918 pub(crate) syntax: SyntaxNode,
@@ -489,7 +925,19 @@ impl EffectExpr {
489 pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) } 925 pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) }
490 pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) } 926 pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
491} 927}
492 928/// For loop expression.
929/// Note: record struct literals are not valid as iterable expression
930/// due to ambiguity.
931///
932/// ```
933/// ❰
934/// for i in (0..4) {
935/// dbg!(i);
936/// }
937/// ❱
938/// ```
939///
940/// [Reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html#iterator-loops)
493#[derive(Debug, Clone, PartialEq, Eq, Hash)] 941#[derive(Debug, Clone, PartialEq, Eq, Hash)]
494pub struct ForExpr { 942pub struct ForExpr {
495 pub(crate) syntax: SyntaxNode, 943 pub(crate) syntax: SyntaxNode,
@@ -502,7 +950,22 @@ impl ForExpr {
502 pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) } 950 pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) }
503 pub fn iterable(&self) -> Option<Expr> { support::child(&self.syntax) } 951 pub fn iterable(&self) -> Option<Expr> { support::child(&self.syntax) }
504} 952}
505 953/// While loop expression. Includes both regular `while` and `while let` forms.
954///
955/// ```
956/// ❰
957/// while bool_cond {
958/// 42;
959/// }
960/// ❱
961/// ❰
962/// while let Pattern(foo) = bar {
963/// bar += 1;
964/// }
965/// ❱
966/// ```
967///
968/// [Reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html#predicate-loops)
506#[derive(Debug, Clone, PartialEq, Eq, Hash)] 969#[derive(Debug, Clone, PartialEq, Eq, Hash)]
507pub struct WhileExpr { 970pub struct WhileExpr {
508 pub(crate) syntax: SyntaxNode, 971 pub(crate) syntax: SyntaxNode,
@@ -513,7 +976,22 @@ impl WhileExpr {
513 pub fn while_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![while]) } 976 pub fn while_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![while]) }
514 pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) } 977 pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) }
515} 978}
516 979/// Continue expression.
980///
981/// ```
982/// while bool_cond {
983/// ❰ continue ❱;
984/// }
985///
986/// 'outer: loop {
987/// loop {
988/// ❰ continue 'outer ❱;
989/// }
990/// }
991///
992/// ```
993///
994/// [Reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html#continue-expressions)
517#[derive(Debug, Clone, PartialEq, Eq, Hash)] 995#[derive(Debug, Clone, PartialEq, Eq, Hash)]
518pub struct ContinueExpr { 996pub struct ContinueExpr {
519 pub(crate) syntax: SyntaxNode, 997 pub(crate) syntax: SyntaxNode,
@@ -527,7 +1005,25 @@ impl ContinueExpr {
527 support::token(&self.syntax, T![lifetime]) 1005 support::token(&self.syntax, T![lifetime])
528 } 1006 }
529} 1007}
530 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)
531#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1027#[derive(Debug, Clone, PartialEq, Eq, Hash)]
532pub struct BreakExpr { 1028pub struct BreakExpr {
533 pub(crate) syntax: SyntaxNode, 1029 pub(crate) syntax: SyntaxNode,
@@ -540,7 +1036,20 @@ impl BreakExpr {
540 } 1036 }
541 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1037 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
542} 1038}
543 1039/// Label.
1040///
1041/// ```
1042/// ❰ 'outer: ❱ loop {}
1043///
1044/// let foo = ❰ 'bar: ❱ loop {}
1045///
1046/// ❰ 'baz: ❱ {
1047/// break 'baz;
1048/// }
1049/// ```
1050///
1051/// [Reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html?highlight=label#loop-labels)
1052/// [Labels for blocks RFC](https://github.com/rust-lang/rfcs/blob/master/text/2046-label-break-value.md)
544#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1053#[derive(Debug, Clone, PartialEq, Eq, Hash)]
545pub struct Label { 1054pub struct Label {
546 pub(crate) syntax: SyntaxNode, 1055 pub(crate) syntax: SyntaxNode,
@@ -550,7 +1059,21 @@ impl Label {
550 support::token(&self.syntax, T![lifetime]) 1059 support::token(&self.syntax, T![lifetime])
551 } 1060 }
552} 1061}
553 1062/// Block expression. Includes unsafe blocks and block labels.
1063///
1064/// ```
1065/// let foo = ❰
1066/// {
1067/// #![inner_attr]
1068/// ❰ { } ❱
1069///
1070/// ❰ 'label: { break 'label } ❱
1071/// }
1072/// ❱;
1073/// ```
1074///
1075/// [Reference](https://doc.rust-lang.org/reference/expressions/block-expr.html)
1076/// [Labels for blocks RFC](https://github.com/rust-lang/rfcs/blob/master/text/2046-label-break-value.md)
554#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1077#[derive(Debug, Clone, PartialEq, Eq, Hash)]
555pub struct BlockExpr { 1078pub struct BlockExpr {
556 pub(crate) syntax: SyntaxNode, 1079 pub(crate) syntax: SyntaxNode,
@@ -563,7 +1086,17 @@ impl BlockExpr {
563 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1086 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
564 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } 1087 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
565} 1088}
566 1089/// Return expression.
1090///
1091/// ```
1092/// || ❰ return 42 ❱;
1093///
1094/// fn bar() {
1095/// ❰ return ❱;
1096/// }
1097/// ```
1098///
1099/// [Reference](https://doc.rust-lang.org/reference/expressions/return-expr.html)
567#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1100#[derive(Debug, Clone, PartialEq, Eq, Hash)]
568pub struct ReturnExpr { 1101pub struct ReturnExpr {
569 pub(crate) syntax: SyntaxNode, 1102 pub(crate) syntax: SyntaxNode,
@@ -572,7 +1105,16 @@ impl ast::AttrsOwner for ReturnExpr {}
572impl ReturnExpr { 1105impl ReturnExpr {
573 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1106 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
574} 1107}
575 1108/// Call expression (not to be confused with method call expression, it is
1109/// a separate ast node).
1110///
1111/// ```
1112/// ❰ foo() ❱;
1113/// ❰ &str::len("bar") ❱;
1114/// ❰ <&str as PartialEq<&str>>::eq(&"", &"") ❱;
1115/// ```
1116///
1117/// [Reference](https://doc.rust-lang.org/reference/expressions/call-expr.html)
576#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1118#[derive(Debug, Clone, PartialEq, Eq, Hash)]
577pub struct CallExpr { 1119pub struct CallExpr {
578 pub(crate) syntax: SyntaxNode, 1120 pub(crate) syntax: SyntaxNode,
@@ -581,7 +1123,16 @@ impl ast::ArgListOwner for CallExpr {}
581impl CallExpr { 1123impl CallExpr {
582 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1124 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
583} 1125}
584 1126/// Method call expression.
1127///
1128/// ```
1129/// ❰ receiver_expr.method() ❱;
1130/// ❰ receiver_expr.method::<T>(42, true) ❱;
1131///
1132/// ❰ ❰ ❰ foo.bar() ❱ .baz() ❱ .bruh() ❱;
1133/// ```
1134///
1135/// [Reference](https://doc.rust-lang.org/reference/expressions/method-call-expr.html)
585#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1136#[derive(Debug, Clone, PartialEq, Eq, Hash)]
586pub struct MethodCallExpr { 1137pub struct MethodCallExpr {
587 pub(crate) syntax: SyntaxNode, 1138 pub(crate) syntax: SyntaxNode,
@@ -594,7 +1145,13 @@ impl MethodCallExpr {
594 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } 1145 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
595 pub fn type_arg_list(&self) -> Option<TypeArgList> { support::child(&self.syntax) } 1146 pub fn type_arg_list(&self) -> Option<TypeArgList> { support::child(&self.syntax) }
596} 1147}
597 1148/// Index expression a.k.a. subscript operator call.
1149///
1150/// ```
1151/// ❰ foo[42] ❱;
1152/// ```
1153///
1154/// [Reference](https://doc.rust-lang.org/reference/expressions/array-expr.html)
598#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1155#[derive(Debug, Clone, PartialEq, Eq, Hash)]
599pub struct IndexExpr { 1156pub struct IndexExpr {
600 pub(crate) syntax: SyntaxNode, 1157 pub(crate) syntax: SyntaxNode,
@@ -604,7 +1161,15 @@ impl IndexExpr {
604 pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } 1161 pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
605 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } 1162 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
606} 1163}
607 1164/// Field access expression.
1165///
1166/// ```
1167/// ❰ expr.bar ❱;
1168///
1169/// ❰ ❰ ❰ foo.bar ❱ .baz ❱ .bruh ❱;
1170/// ```
1171///
1172/// [Reference](https://doc.rust-lang.org/reference/expressions/field-expr.html)
608#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1173#[derive(Debug, Clone, PartialEq, Eq, Hash)]
609pub struct FieldExpr { 1174pub struct FieldExpr {
610 pub(crate) syntax: SyntaxNode, 1175 pub(crate) syntax: SyntaxNode,
@@ -615,7 +1180,13 @@ impl FieldExpr {
615 pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) } 1180 pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
616 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } 1181 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
617} 1182}
618 1183/// Await operator call expression.
1184///
1185/// ```
1186/// ❰ expr.await ❱;
1187/// ```
1188///
1189/// [Reference](https://doc.rust-lang.org/reference/expressions/await-expr.html)
619#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1190#[derive(Debug, Clone, PartialEq, Eq, Hash)]
620pub struct AwaitExpr { 1191pub struct AwaitExpr {
621 pub(crate) syntax: SyntaxNode, 1192 pub(crate) syntax: SyntaxNode,
@@ -626,7 +1197,13 @@ impl AwaitExpr {
626 pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) } 1197 pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) }
627 pub fn await_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![await]) } 1198 pub fn await_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![await]) }
628} 1199}
629 1200/// The question mark operator call.
1201///
1202/// ```
1203/// ❰ expr? ❱;
1204/// ```
1205///
1206/// [Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#the-question-mark-operator)
630#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1207#[derive(Debug, Clone, PartialEq, Eq, Hash)]
631pub struct TryExpr { 1208pub struct TryExpr {
632 pub(crate) syntax: SyntaxNode, 1209 pub(crate) syntax: SyntaxNode,
@@ -636,7 +1213,13 @@ impl TryExpr {
636 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1213 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
637 pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) } 1214 pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) }
638} 1215}
639 1216/// Type cast expression.
1217///
1218/// ```
1219/// ❰ expr as T ❱;
1220/// ```
1221///
1222/// [Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#type-cast-expressions)
640#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1223#[derive(Debug, Clone, PartialEq, Eq, Hash)]
641pub struct CastExpr { 1224pub struct CastExpr {
642 pub(crate) syntax: SyntaxNode, 1225 pub(crate) syntax: SyntaxNode,
@@ -647,7 +1230,14 @@ impl CastExpr {
647 pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) } 1230 pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
648 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 1231 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
649} 1232}
650 1233/// Borrow operator call.
1234///
1235/// ```
1236/// ❰ &foo ❱;
1237/// ❰ &mut bar ❱;
1238/// ```
1239///
1240/// [Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#borrow-operators)
651#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1241#[derive(Debug, Clone, PartialEq, Eq, Hash)]
652pub struct RefExpr { 1242pub struct RefExpr {
653 pub(crate) syntax: SyntaxNode, 1243 pub(crate) syntax: SyntaxNode,
@@ -659,7 +1249,15 @@ impl RefExpr {
659 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } 1249 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
660 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1250 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
661} 1251}
662 1252/// Prefix operator call. This is either `!` or `*` or `-`.
1253///
1254/// ```
1255/// ❰ !foo ❱;
1256/// ❰ *bar ❱;
1257/// ❰ -42 ❱;
1258/// ```
1259///
1260/// [Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html)
663#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1261#[derive(Debug, Clone, PartialEq, Eq, Hash)]
664pub struct PrefixExpr { 1262pub struct PrefixExpr {
665 pub(crate) syntax: SyntaxNode, 1263 pub(crate) syntax: SyntaxNode,
@@ -668,7 +1266,13 @@ impl ast::AttrsOwner for PrefixExpr {}
668impl PrefixExpr { 1266impl PrefixExpr {
669 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1267 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
670} 1268}
671 1269/// Box operator call.
1270///
1271/// ```
1272/// ❰ box 42 ❱;
1273/// ```
1274///
1275/// [RFC](https://github.com/rust-lang/rfcs/blob/0806be4f282144cfcd55b1d20284b43f87cbe1c6/text/0809-box-and-in-for-stdlib.md)
672#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1276#[derive(Debug, Clone, PartialEq, Eq, Hash)]
673pub struct BoxExpr { 1277pub struct BoxExpr {
674 pub(crate) syntax: SyntaxNode, 1278 pub(crate) syntax: SyntaxNode,
@@ -678,27 +1282,69 @@ impl BoxExpr {
678 pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) } 1282 pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) }
679 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1283 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
680} 1284}
681 1285/// Range operator call.
1286///
1287/// ```
1288/// ❰ 0..42 ❱;
1289/// ❰ ..42 ❱;
1290/// ❰ 0.. ❱;
1291/// ❰ .. ❱;
1292/// ❰ 0..=42 ❱;
1293/// ❰ ..=42 ❱;
1294/// ```
1295///
1296/// [Reference](https://doc.rust-lang.org/reference/expressions/range-expr.html)
682#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1297#[derive(Debug, Clone, PartialEq, Eq, Hash)]
683pub struct RangeExpr { 1298pub struct RangeExpr {
684 pub(crate) syntax: SyntaxNode, 1299 pub(crate) syntax: SyntaxNode,
685} 1300}
686impl ast::AttrsOwner for RangeExpr {} 1301impl ast::AttrsOwner for RangeExpr {}
687impl RangeExpr {} 1302impl RangeExpr {}
688 1303/// Binary operator call.
1304/// Includes all arithmetic, logic, bitwise and assignment operators.
1305///
1306/// ```
1307/// ❰ 2 + ❰ 2 * 2 ❱ ❱;
1308/// ❰ ❰ true && false ❱ || true ❱;
1309/// ```
1310///
1311/// [Reference](https://doc.rust-lang.org/reference/expressions/operator-expr.html#arithmetic-and-logical-binary-operators)
689#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1312#[derive(Debug, Clone, PartialEq, Eq, Hash)]
690pub struct BinExpr { 1313pub struct BinExpr {
691 pub(crate) syntax: SyntaxNode, 1314 pub(crate) syntax: SyntaxNode,
692} 1315}
693impl ast::AttrsOwner for BinExpr {} 1316impl ast::AttrsOwner for BinExpr {}
694impl BinExpr {} 1317impl BinExpr {}
695 1318/// [Raw] string, [raw] byte string, char, byte, integer, float or bool literal.
1319///
1320/// ```
1321/// ❰ "str" ❱;
1322/// ❰ br##"raw byte str"## ❱;
1323/// ❰ 'c' ❱;
1324/// ❰ b'c' ❱;
1325/// ❰ 42 ❱;
1326/// ❰ 1e9 ❱;
1327/// ❰ true ❱;
1328/// ```
1329///
1330/// [Reference](https://doc.rust-lang.org/reference/expressions/literal-expr.html)
696#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1331#[derive(Debug, Clone, PartialEq, Eq, Hash)]
697pub struct Literal { 1332pub struct Literal {
698 pub(crate) syntax: SyntaxNode, 1333 pub(crate) syntax: SyntaxNode,
699} 1334}
700impl Literal {} 1335impl Literal {}
701 1336/// Match expression.
1337///
1338/// ```
1339/// ❰
1340/// match expr {
1341/// Pat1 => {}
1342/// Pat2(_) => 42,
1343/// }
1344/// ❱
1345/// ```
1346///
1347/// [Reference](https://doc.rust-lang.org/reference/expressions/match-expr.html)
702#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1348#[derive(Debug, Clone, PartialEq, Eq, Hash)]
703pub struct MatchExpr { 1349pub struct MatchExpr {
704 pub(crate) syntax: SyntaxNode, 1350 pub(crate) syntax: SyntaxNode,
@@ -709,7 +1355,20 @@ impl MatchExpr {
709 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1355 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
710 pub fn match_arm_list(&self) -> Option<MatchArmList> { support::child(&self.syntax) } 1356 pub fn match_arm_list(&self) -> Option<MatchArmList> { support::child(&self.syntax) }
711} 1357}
712 1358/// Match arm list part of match expression. Includes its inner attributes.
1359///
1360/// ```
1361/// match expr
1362/// ❰
1363/// {
1364/// #![inner_attr]
1365/// Pat1 => {}
1366/// Pat2(_) => 42,
1367/// }
1368/// ❱
1369/// ```
1370///
1371/// [Reference](https://doc.rust-lang.org/reference/expressions/match-expr.html)
713#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1372#[derive(Debug, Clone, PartialEq, Eq, Hash)]
714pub struct MatchArmList { 1373pub struct MatchArmList {
715 pub(crate) syntax: SyntaxNode, 1374 pub(crate) syntax: SyntaxNode,
@@ -720,7 +1379,16 @@ impl MatchArmList {
720 pub fn arms(&self) -> AstChildren<MatchArm> { support::children(&self.syntax) } 1379 pub fn arms(&self) -> AstChildren<MatchArm> { support::children(&self.syntax) }
721 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } 1380 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
722} 1381}
723 1382/// Match arm.
1383/// Note: record struct literals are not valid as target match expression
1384/// due to ambiguity.
1385/// ```
1386/// match expr {
1387/// ❰ #[attr] Pattern(it) if bool_cond => it ❱,
1388/// }
1389/// ```
1390///
1391/// [Reference](https://doc.rust-lang.org/reference/expressions/match-expr.html)
724#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1392#[derive(Debug, Clone, PartialEq, Eq, Hash)]
725pub struct MatchArm { 1393pub struct MatchArm {
726 pub(crate) syntax: SyntaxNode, 1394 pub(crate) syntax: SyntaxNode,
@@ -732,7 +1400,15 @@ impl MatchArm {
732 pub fn fat_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=>]) } 1400 pub fn fat_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=>]) }
733 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1401 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
734} 1402}
735 1403/// Match guard.
1404///
1405/// ```
1406/// match expr {
1407/// Pattern(it) ❰ if bool_cond ❱ => it,
1408/// }
1409/// ```
1410///
1411/// [Reference](https://doc.rust-lang.org/reference/expressions/match-expr.html#match-guards)
736#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1412#[derive(Debug, Clone, PartialEq, Eq, Hash)]
737pub struct MatchGuard { 1413pub struct MatchGuard {
738 pub(crate) syntax: SyntaxNode, 1414 pub(crate) syntax: SyntaxNode,
@@ -741,7 +1417,21 @@ impl MatchGuard {
741 pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) } 1417 pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) }
742 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1418 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
743} 1419}
744 1420/// Record literal expression. The same syntax is used for structs,
1421/// unions and record enum variants.
1422///
1423/// ```
1424/// ❰
1425/// foo::Bar {
1426/// #![inner_attr]
1427/// baz: 42,
1428/// bruh: true,
1429/// ..spread
1430/// }
1431/// ❱
1432/// ```
1433///
1434/// [Reference](https://doc.rust-lang.org/reference/expressions/struct-expr.html)
745#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1435#[derive(Debug, Clone, PartialEq, Eq, Hash)]
746pub struct RecordLit { 1436pub struct RecordLit {
747 pub(crate) syntax: SyntaxNode, 1437 pub(crate) syntax: SyntaxNode,
@@ -750,7 +1440,16 @@ impl RecordLit {
750 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } 1440 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
751 pub fn record_field_list(&self) -> Option<RecordFieldList> { support::child(&self.syntax) } 1441 pub fn record_field_list(&self) -> Option<RecordFieldList> { support::child(&self.syntax) }
752} 1442}
753 1443/// Record field list including enclosing curly braces.
1444///
1445/// foo::Bar ❰
1446/// {
1447/// baz: 42,
1448/// ..spread
1449/// }
1450/// ❱
1451///
1452/// [Reference](https://doc.rust-lang.org/reference/expressions/struct-expr.html)
754#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1453#[derive(Debug, Clone, PartialEq, Eq, Hash)]
755pub struct RecordFieldList { 1454pub struct RecordFieldList {
756 pub(crate) syntax: SyntaxNode, 1455 pub(crate) syntax: SyntaxNode,
@@ -762,7 +1461,15 @@ impl RecordFieldList {
762 pub fn spread(&self) -> Option<Expr> { support::child(&self.syntax) } 1461 pub fn spread(&self) -> Option<Expr> { support::child(&self.syntax) }
763 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } 1462 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
764} 1463}
765 1464/// Record field.
1465///
1466/// ```
1467/// foo::Bar {
1468/// ❰ #[attr] baz: 42 ❱
1469/// }
1470/// ```
1471///
1472/// [Reference](https://doc.rust-lang.org/reference/expressions/struct-expr.html)
766#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1473#[derive(Debug, Clone, PartialEq, Eq, Hash)]
767pub struct RecordField { 1474pub struct RecordField {
768 pub(crate) syntax: SyntaxNode, 1475 pub(crate) syntax: SyntaxNode,
@@ -773,7 +1480,13 @@ impl RecordField {
773 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } 1480 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
774 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 1481 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
775} 1482}
776 1483/// Disjunction of patterns.
1484///
1485/// ```
1486/// let ❰ Foo(it) | Bar(it) | Baz(it) ❱ = bruh;
1487/// ```
1488///
1489/// [Reference](https://doc.rust-lang.org/reference/patterns.html)
777#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1490#[derive(Debug, Clone, PartialEq, Eq, Hash)]
778pub struct OrPat { 1491pub struct OrPat {
779 pub(crate) syntax: SyntaxNode, 1492 pub(crate) syntax: SyntaxNode,
@@ -781,7 +1494,14 @@ pub struct OrPat {
781impl OrPat { 1494impl OrPat {
782 pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) } 1495 pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
783} 1496}
784 1497/// Parenthesized pattern.
1498/// Note: parens are only used for grouping, this is not a tuple pattern.
1499///
1500/// ```
1501/// if let ❰ &(0..=42) ❱ = foo {}
1502/// ```
1503///
1504/// https://doc.rust-lang.org/reference/patterns.html#grouped-patterns
785#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1505#[derive(Debug, Clone, PartialEq, Eq, Hash)]
786pub struct ParenPat { 1506pub struct ParenPat {
787 pub(crate) syntax: SyntaxNode, 1507 pub(crate) syntax: SyntaxNode,
@@ -791,7 +1511,16 @@ impl ParenPat {
791 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 1511 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
792 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } 1512 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
793} 1513}
794 1514/// Reference pattern.
1515/// Note: this has nothing to do with `ref` keyword, the latter is used in bind patterns.
1516///
1517/// ```
1518/// let ❰ &mut foo ❱ = bar;
1519///
1520/// let ❰ & ❰ &mut ❰ &_ ❱ ❱ ❱ = baz;
1521/// ```
1522///
1523/// [Reference](https://doc.rust-lang.org/reference/patterns.html#reference-patterns)
795#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1524#[derive(Debug, Clone, PartialEq, Eq, Hash)]
796pub struct RefPat { 1525pub struct RefPat {
797 pub(crate) syntax: SyntaxNode, 1526 pub(crate) syntax: SyntaxNode,
@@ -801,7 +1530,13 @@ impl RefPat {
801 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } 1530 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
802 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 1531 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
803} 1532}
804 1533/// Box pattern.
1534///
1535/// ```
1536/// let ❰ box foo ❱ = box 42;
1537/// ```
1538///
1539/// [Unstable book](https://doc.rust-lang.org/unstable-book/language-features/box-patterns.html)
805#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1540#[derive(Debug, Clone, PartialEq, Eq, Hash)]
806pub struct BoxPat { 1541pub struct BoxPat {
807 pub(crate) syntax: SyntaxNode, 1542 pub(crate) syntax: SyntaxNode,
@@ -810,7 +1545,16 @@ impl BoxPat {
810 pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) } 1545 pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) }
811 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 1546 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
812} 1547}
813 1548/// Bind pattern.
1549///
1550/// ```
1551/// match foo {
1552/// Some(❰ ref mut bar ❱) => {}
1553/// ❰ baz @ None ❱ => {}
1554/// }
1555/// ```
1556///
1557/// [Reference](https://doc.rust-lang.org/reference/patterns.html#identifier-patterns)
814#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1558#[derive(Debug, Clone, PartialEq, Eq, Hash)]
815pub struct BindPat { 1559pub struct BindPat {
816 pub(crate) syntax: SyntaxNode, 1560 pub(crate) syntax: SyntaxNode,
@@ -823,7 +1567,13 @@ impl BindPat {
823 pub fn at_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![@]) } 1567 pub fn at_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![@]) }
824 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 1568 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
825} 1569}
826 1570/// Placeholder pattern a.k.a. the wildcard pattern or the underscore.
1571///
1572/// ```
1573/// let ❰ _ ❱ = foo;
1574/// ```
1575///
1576/// [Reference](https://doc.rust-lang.org/reference/patterns.html#wildcard-pattern)
827#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1577#[derive(Debug, Clone, PartialEq, Eq, Hash)]
828pub struct PlaceholderPat { 1578pub struct PlaceholderPat {
829 pub(crate) syntax: SyntaxNode, 1579 pub(crate) syntax: SyntaxNode,
@@ -831,7 +1581,16 @@ pub struct PlaceholderPat {
831impl PlaceholderPat { 1581impl PlaceholderPat {
832 pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) } 1582 pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
833} 1583}
834 1584/// Rest-of-the record/tuple pattern.
1585/// Note: this is not the unbonded range pattern (even more: it doesn't exist).
1586///
1587/// ```
1588/// let Foo { bar, ❰ .. ❱ } = baz;
1589/// let (❰ .. ❱, bruh) = (42, 24, 42);
1590/// let Bruuh(❰ .. ❱) = bruuuh;
1591/// ```
1592///
1593/// [Reference](https://doc.rust-lang.org/reference/patterns.html#struct-patterns)
835#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1594#[derive(Debug, Clone, PartialEq, Eq, Hash)]
836pub struct DotDotPat { 1595pub struct DotDotPat {
837 pub(crate) syntax: SyntaxNode, 1596 pub(crate) syntax: SyntaxNode,
@@ -839,7 +1598,15 @@ pub struct DotDotPat {
839impl DotDotPat { 1598impl DotDotPat {
840 pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) } 1599 pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
841} 1600}
842 1601/// Path pattern.
1602/// Doesn't include the underscore pattern (it is a special case, namely `PlaceholderPat`).
1603///
1604/// ```
1605/// let ❰ foo::bar::Baz ❱ { .. } = bruh;
1606/// if let ❰ CONST ❱ = 42 {}
1607/// ```
1608///
1609/// [Reference](https://doc.rust-lang.org/reference/patterns.html#path-patterns)
843#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1610#[derive(Debug, Clone, PartialEq, Eq, Hash)]
844pub struct PathPat { 1611pub struct PathPat {
845 pub(crate) syntax: SyntaxNode, 1612 pub(crate) syntax: SyntaxNode,
@@ -847,7 +1614,13 @@ pub struct PathPat {
847impl PathPat { 1614impl PathPat {
848 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } 1615 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
849} 1616}
850 1617/// Slice pattern.
1618///
1619/// ```
1620/// let ❰ [foo, bar, baz] ❱ = [1, 2, 3];
1621/// ```
1622///
1623/// [Reference](https://doc.rust-lang.org/reference/patterns.html#slice-patterns)
851#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1624#[derive(Debug, Clone, PartialEq, Eq, Hash)]
852pub struct SlicePat { 1625pub struct SlicePat {
853 pub(crate) syntax: SyntaxNode, 1626 pub(crate) syntax: SyntaxNode,
@@ -857,13 +1630,33 @@ impl SlicePat {
857 pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) } 1630 pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
858 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } 1631 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
859} 1632}
860 1633/// Range pattern.
1634///
1635/// ```
1636/// match foo {
1637/// ❰ 0..42 ❱ => {}
1638/// ❰ 0..=42 ❱ => {}
1639/// }
1640/// ```
1641///
1642/// [Reference](https://doc.rust-lang.org/reference/patterns.html#range-patterns)
861#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1643#[derive(Debug, Clone, PartialEq, Eq, Hash)]
862pub struct RangePat { 1644pub struct RangePat {
863 pub(crate) syntax: SyntaxNode, 1645 pub(crate) syntax: SyntaxNode,
864} 1646}
865impl RangePat {} 1647impl RangePat {}
866 1648/// Literal pattern.
1649/// Includes only bool, number, char, and string literals.
1650///
1651/// ```
1652/// match foo {
1653/// Number(❰ 42 ❱) => {}
1654/// String(❰ "42" ❱) => {}
1655/// Bool(❰ true ❱) => {}
1656/// }
1657/// ```
1658///
1659/// [Reference](https://doc.rust-lang.org/reference/patterns.html#literal-patterns)
867#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1660#[derive(Debug, Clone, PartialEq, Eq, Hash)]
868pub struct LiteralPat { 1661pub struct LiteralPat {
869 pub(crate) syntax: SyntaxNode, 1662 pub(crate) syntax: SyntaxNode,
@@ -871,7 +1664,13 @@ pub struct LiteralPat {
871impl LiteralPat { 1664impl LiteralPat {
872 pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) } 1665 pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) }
873} 1666}
874 1667/// Macro invocation in pattern position.
1668///
1669/// ```
1670/// let ❰ foo!(my custom syntax) ❱ = baz;
1671///
1672/// ```
1673/// [Reference](https://doc.rust-lang.org/reference/macros.html#macro-invocation)
875#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1674#[derive(Debug, Clone, PartialEq, Eq, Hash)]
876pub struct MacroPat { 1675pub struct MacroPat {
877 pub(crate) syntax: SyntaxNode, 1676 pub(crate) syntax: SyntaxNode,
@@ -879,7 +1678,13 @@ pub struct MacroPat {
879impl MacroPat { 1678impl MacroPat {
880 pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) } 1679 pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) }
881} 1680}
882 1681/// Record literal pattern.
1682///
1683/// ```
1684/// let ❰ foo::Bar { baz, .. } ❱ = bruh;
1685/// ```
1686///
1687/// [Reference](https://doc.rust-lang.org/reference/patterns.html#struct-patterns)
883#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1688#[derive(Debug, Clone, PartialEq, Eq, Hash)]
884pub struct RecordPat { 1689pub struct RecordPat {
885 pub(crate) syntax: SyntaxNode, 1690 pub(crate) syntax: SyntaxNode,
@@ -890,7 +1695,13 @@ impl RecordPat {
890 } 1695 }
891 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } 1696 pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
892} 1697}
893 1698/// Record literal's field patterns list including enclosing curly braces.
1699///
1700/// ```
1701/// let foo::Bar ❰ { baz, bind @ bruh, .. } ❱ = bruuh;
1702/// ``
1703///
1704/// [Reference](https://doc.rust-lang.org/reference/patterns.html#struct-patterns)
894#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1705#[derive(Debug, Clone, PartialEq, Eq, Hash)]
895pub struct RecordFieldPatList { 1706pub struct RecordFieldPatList {
896 pub(crate) syntax: SyntaxNode, 1707 pub(crate) syntax: SyntaxNode,
@@ -905,7 +1716,15 @@ impl RecordFieldPatList {
905 pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) } 1716 pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) }
906 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } 1717 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
907} 1718}
908 1719/// Record literal's field pattern.
1720/// Note: record literal can also match tuple structs.
1721///
1722/// ```
1723/// let Foo { ❰ bar: _ ❱ } = baz;
1724/// let TupleStruct { ❰ 0: _ ❱ } = bruh;
1725/// ```
1726///
1727/// [Reference](https://doc.rust-lang.org/reference/patterns.html#struct-patterns)
909#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1728#[derive(Debug, Clone, PartialEq, Eq, Hash)]
910pub struct RecordFieldPat { 1729pub struct RecordFieldPat {
911 pub(crate) syntax: SyntaxNode, 1730 pub(crate) syntax: SyntaxNode,
@@ -916,7 +1735,13 @@ impl RecordFieldPat {
916 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } 1735 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
917 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 1736 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
918} 1737}
919 1738/// Tuple struct literal pattern.
1739///
1740/// ```
1741/// let ❰ foo::Bar(baz, bruh) ❱ = bruuh;
1742/// ```
1743///
1744/// [Reference](https://doc.rust-lang.org/reference/patterns.html#tuple-struct-patterns)
920#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1745#[derive(Debug, Clone, PartialEq, Eq, Hash)]
921pub struct TupleStructPat { 1746pub struct TupleStructPat {
922 pub(crate) syntax: SyntaxNode, 1747 pub(crate) syntax: SyntaxNode,
@@ -927,7 +1752,14 @@ impl TupleStructPat {
927 pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) } 1752 pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
928 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } 1753 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
929} 1754}
930 1755/// Tuple pattern.
1756/// Note: this doesn't include tuple structs (see `TupleStructPat`)
1757///
1758/// ```
1759/// let ❰ (foo, bar, .., baz) ❱ = bruh;
1760/// ```
1761///
1762/// [Reference](https://doc.rust-lang.org/reference/patterns.html#tuple-patterns)
931#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1763#[derive(Debug, Clone, PartialEq, Eq, Hash)]
932pub struct TuplePat { 1764pub struct TuplePat {
933 pub(crate) syntax: SyntaxNode, 1765 pub(crate) syntax: SyntaxNode,
@@ -937,7 +1769,17 @@ impl TuplePat {
937 pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) } 1769 pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) }
938 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } 1770 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
939} 1771}
940 1772/// Visibility.
1773///
1774/// ```
1775/// ❰ pub mod ❱ foo;
1776/// ❰ pub(crate) ❱ struct Bar;
1777/// ❰ pub(self) ❱ enum Baz {}
1778/// ❰ pub(super) ❱ fn bruh() {}
1779/// ❰ pub(in bruuh::bruuuh) ❱ type T = u64;
1780/// ```
1781///
1782/// [Reference](https://doc.rust-lang.org/reference/visibility-and-privacy.html)
941#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1783#[derive(Debug, Clone, PartialEq, Eq, Hash)]
942pub struct Visibility { 1784pub struct Visibility {
943 pub(crate) syntax: SyntaxNode, 1785 pub(crate) syntax: SyntaxNode,
@@ -948,7 +1790,29 @@ impl Visibility {
948 pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) } 1790 pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
949 pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) } 1791 pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) }
950} 1792}
951 1793/// Single identifier.
1794/// Note(@matklad): `Name` is for things that install a new name into the scope,
1795/// `NameRef` is a usage of a name. Most of the time, this definition/reference
1796/// distinction can be determined purely syntactically, ie in
1797/// ```
1798/// fn foo() { foo() }
1799/// ```
1800/// the first foo is `Name`, the second one is `NameRef`.
1801/// The notable exception are patterns, where in
1802/// ``
1803/// let x = 92
1804/// ```
1805/// `x` can be semantically either a name or a name ref, depeding on
1806/// wether there's an `x` constant in scope.
1807/// We use `Name` for patterns, and disambiguate semantically (see `NameClass` in ide_db).
1808///
1809/// ```
1810/// let ❰ foo ❱ = bar;
1811/// struct ❰ Baz ❱;
1812/// fn ❰ bruh ❱() {}
1813/// ```
1814///
1815/// [Reference](https://doc.rust-lang.org/reference/identifiers.html)
952#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1816#[derive(Debug, Clone, PartialEq, Eq, Hash)]
953pub struct Name { 1817pub struct Name {
954 pub(crate) syntax: SyntaxNode, 1818 pub(crate) syntax: SyntaxNode,
@@ -956,13 +1820,41 @@ pub struct Name {
956impl Name { 1820impl Name {
957 pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) } 1821 pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) }
958} 1822}
959 1823/// Reference to a name.
1824/// See the explanation on the difference between `Name` and `NameRef`
1825/// in `Name` ast node docs.
1826///
1827/// ```
1828/// let foo = ❰ bar ❱(❰ Baz(❰ bruh ❱) ❱;
1829/// ```
1830///
1831/// [Reference](https://doc.rust-lang.org/reference/identifiers.html)
960#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1832#[derive(Debug, Clone, PartialEq, Eq, Hash)]
961pub struct NameRef { 1833pub struct NameRef {
962 pub(crate) syntax: SyntaxNode, 1834 pub(crate) syntax: SyntaxNode,
963} 1835}
964impl NameRef {} 1836impl NameRef {}
965 1837/// Macro call.
1838/// Includes all of its attributes and doc comments.
1839///
1840/// ```
1841/// ❰
1842/// /// Docs
1843/// #[attr]
1844/// macro_rules! foo { // macro rules is also a macro call
1845/// ($bar: tt) => {}
1846/// }
1847/// ❱
1848///
1849/// // semicolon is a part of `MacroCall` when it is used in item positions
1850/// ❰ foo!(); ❱
1851///
1852/// fn main() {
1853/// ❰ foo!() ❱; // macro call in expression positions doesn't include the semi
1854/// }
1855/// ```
1856///
1857/// [Reference](https://doc.rust-lang.org/reference/macros.html)
966#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1858#[derive(Debug, Clone, PartialEq, Eq, Hash)]
967pub struct MacroCall { 1859pub struct MacroCall {
968 pub(crate) syntax: SyntaxNode, 1860 pub(crate) syntax: SyntaxNode,
@@ -976,7 +1868,18 @@ impl MacroCall {
976 pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) } 1868 pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
977 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } 1869 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
978} 1870}
979 1871/// Attribute.
1872///
1873/// ```
1874/// ❰ #![inner_attr] ❱
1875///
1876/// ❰ #[attr] ❱
1877/// ❰ #[foo = "bar"] ❱
1878/// ❰ #[baz(bruh::bruuh = "42")] ❱
1879/// struct Foo;
1880/// ```
1881///
1882/// [Reference](https://doc.rust-lang.org/reference/attributes.html)
980#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1883#[derive(Debug, Clone, PartialEq, Eq, Hash)]
981pub struct Attr { 1884pub struct Attr {
982 pub(crate) syntax: SyntaxNode, 1885 pub(crate) syntax: SyntaxNode,
@@ -990,13 +1893,32 @@ impl Attr {
990 pub fn input(&self) -> Option<AttrInput> { support::child(&self.syntax) } 1893 pub fn input(&self) -> Option<AttrInput> { support::child(&self.syntax) }
991 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } 1894 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
992} 1895}
993 1896/// Stores a list of lexer tokens and other `TokenTree`s.
1897/// It appears in attributes, macro_rules and macro call (foo!)
1898///
1899/// ```
1900/// macro_call! ❰ { my syntax here } ❱;
1901/// ```
1902///
1903/// [Reference](https://doc.rust-lang.org/reference/macros.html)
994#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1904#[derive(Debug, Clone, PartialEq, Eq, Hash)]
995pub struct TokenTree { 1905pub struct TokenTree {
996 pub(crate) syntax: SyntaxNode, 1906 pub(crate) syntax: SyntaxNode,
997} 1907}
998impl TokenTree {} 1908impl TokenTree {}
999 1909/// Generic lifetime, type and constants parameters list **declaration**.
1910///
1911/// ```
1912/// fn foo❰ <'a, 'b, T, U, const BAR: u64> ❱() {}
1913///
1914/// struct Baz❰ <T> ❱(T);
1915///
1916/// impl❰ <T> ❱ Bruh<T> {}
1917///
1918/// type Bruuh = for❰ <'a> ❱ fn(&'a str) -> &'a str;
1919/// ```
1920///
1921/// [Reference](https://doc.rust-lang.org/reference/items/generics.html)
1000#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1922#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1001pub struct TypeParamList { 1923pub struct TypeParamList {
1002 pub(crate) syntax: SyntaxNode, 1924 pub(crate) syntax: SyntaxNode,
@@ -1009,7 +1931,13 @@ impl TypeParamList {
1009 pub fn const_params(&self) -> AstChildren<ConstParam> { support::children(&self.syntax) } 1931 pub fn const_params(&self) -> AstChildren<ConstParam> { support::children(&self.syntax) }
1010 pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) } 1932 pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
1011} 1933}
1012 1934/// Single type parameter **declaration**.
1935///
1936/// ```
1937/// fn foo<❰ K ❱, ❰ I ❱, ❰ E: Debug ❱, ❰ V = DefaultType ❱>() {}
1938/// ```
1939///
1940/// [Reference](https://doc.rust-lang.org/reference/items/generics.html)
1013#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1941#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1014pub struct TypeParam { 1942pub struct TypeParam {
1015 pub(crate) syntax: SyntaxNode, 1943 pub(crate) syntax: SyntaxNode,
@@ -1021,7 +1949,12 @@ impl TypeParam {
1021 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } 1949 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
1022 pub fn default_type(&self) -> Option<TypeRef> { support::child(&self.syntax) } 1950 pub fn default_type(&self) -> Option<TypeRef> { support::child(&self.syntax) }
1023} 1951}
1024 1952/// Const generic parameter **declaration**.
1953/// ```
1954/// fn foo<T, U, ❰ const BAR: usize ❱, ❰ const BAZ: bool ❱>() {}
1955/// ```
1956///
1957/// [RFC](https://github.com/rust-lang/rfcs/blob/master/text/2000-const-generics.md#declaring-a-const-parameter)
1025#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1958#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1026pub struct ConstParam { 1959pub struct ConstParam {
1027 pub(crate) syntax: SyntaxNode, 1960 pub(crate) syntax: SyntaxNode,
@@ -1033,7 +1966,13 @@ impl ConstParam {
1033 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } 1966 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
1034 pub fn default_val(&self) -> Option<Expr> { support::child(&self.syntax) } 1967 pub fn default_val(&self) -> Option<Expr> { support::child(&self.syntax) }
1035} 1968}
1036 1969/// Lifetime parameter **declaration**.
1970///
1971/// ```
1972/// fn foo<❰ 'a ❱, ❰ 'b ❱, V, G, D>(bar: &'a str, baz: &'b mut str) {}
1973/// ```
1974///
1975/// [Reference](https://doc.rust-lang.org/reference/items/generics.html)
1037#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1976#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1038pub struct LifetimeParam { 1977pub struct LifetimeParam {
1039 pub(crate) syntax: SyntaxNode, 1978 pub(crate) syntax: SyntaxNode,
@@ -1044,7 +1983,20 @@ impl LifetimeParam {
1044 support::token(&self.syntax, T![lifetime]) 1983 support::token(&self.syntax, T![lifetime])
1045 } 1984 }
1046} 1985}
1047 1986/// Type bound declaration clause.
1987///
1988/// ```
1989/// fn foo<T: ❰ ?Sized ❱ + ❰ Debug ❱>() {}
1990///
1991/// trait Bar<T>
1992/// where
1993/// T: ❰ Send ❱ + ❰ Sync ❱
1994/// {
1995/// type Baz: ❰ !Sync ❱ + ❰ Debug ❱ + ❰ ?const Add ❱;
1996/// }
1997/// ```
1998///
1999/// [Reference](https://doc.rust-lang.org/reference/trait-bounds.html)
1048#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2000#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1049pub struct TypeBound { 2001pub struct TypeBound {
1050 pub(crate) syntax: SyntaxNode, 2002 pub(crate) syntax: SyntaxNode,
@@ -1056,7 +2008,21 @@ impl TypeBound {
1056 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } 2008 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
1057 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 2009 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
1058} 2010}
1059 2011/// Type bounds list.
2012///
2013/// ```
2014///
2015/// fn foo<T: ❰ ?Sized + Debug ❱>() {}
2016///
2017/// trait Bar<T>
2018/// where
2019/// T: ❰ Send + Sync ❱
2020/// {
2021/// type Baz: ❰ !Sync + Debug ❱;
2022/// }
2023/// ```
2024///
2025/// [Reference](https://doc.rust-lang.org/reference/trait-bounds.html)
1060#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2026#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1061pub struct TypeBoundList { 2027pub struct TypeBoundList {
1062 pub(crate) syntax: SyntaxNode, 2028 pub(crate) syntax: SyntaxNode,
@@ -1064,7 +2030,18 @@ pub struct TypeBoundList {
1064impl TypeBoundList { 2030impl TypeBoundList {
1065 pub fn bounds(&self) -> AstChildren<TypeBound> { support::children(&self.syntax) } 2031 pub fn bounds(&self) -> AstChildren<TypeBound> { support::children(&self.syntax) }
1066} 2032}
1067 2033/// Single where predicate.
2034///
2035/// ```
2036/// trait Foo<'a, 'b, T>
2037/// where
2038/// ❰ 'a: 'b ❱,
2039/// ❰ T: IntoIterator ❱,
2040/// ❰ for<'c> <T as IntoIterator>::Item: Bar<'c> ❱
2041/// {}
2042/// ```
2043///
2044/// [Reference](https://doc.rust-lang.org/reference/items/generics.html#where-clauses)
1068#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2045#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1069pub struct WherePred { 2046pub struct WherePred {
1070 pub(crate) syntax: SyntaxNode, 2047 pub(crate) syntax: SyntaxNode,
@@ -1076,7 +2053,14 @@ impl WherePred {
1076 } 2053 }
1077 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 2054 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
1078} 2055}
1079 2056/// Where clause.
2057///
2058/// ```
2059/// trait Foo<'a, T> ❰ where 'a: 'static, T: Debug ❱ {}
2060///
2061/// ```
2062///
2063/// [Reference](https://doc.rust-lang.org/reference/items/generics.html#where-clauses)
1080#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2064#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1081pub struct WhereClause { 2065pub struct WhereClause {
1082 pub(crate) syntax: SyntaxNode, 2066 pub(crate) syntax: SyntaxNode,
@@ -1085,13 +2069,42 @@ impl WhereClause {
1085 pub fn where_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![where]) } 2069 pub fn where_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![where]) }
1086 pub fn predicates(&self) -> AstChildren<WherePred> { support::children(&self.syntax) } 2070 pub fn predicates(&self) -> AstChildren<WherePred> { support::children(&self.syntax) }
1087} 2071}
1088 2072/// Abi declaration.
2073/// Note: the abi string is optional.
2074///
2075/// ```
2076/// ❰ extern "C" ❱ {
2077/// fn foo() {}
2078/// }
2079///
2080/// type Bar = ❰ extern ❱ fn() -> u32;
2081///
2082/// type Baz = ❰ extern r#"stdcall"# ❱ fn() -> bool;
2083/// ```
2084///
2085/// - [Extern blocks reference](https://doc.rust-lang.org/reference/items/external-blocks.html)
2086/// - [FFI function pointers reference](https://doc.rust-lang.org/reference/items/functions.html#functions)
1089#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2087#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1090pub struct Abi { 2088pub struct Abi {
1091 pub(crate) syntax: SyntaxNode, 2089 pub(crate) syntax: SyntaxNode,
1092} 2090}
1093impl Abi {} 2091impl Abi {}
1094 2092/// Expression statement.
2093///
2094/// ```
2095/// ❰ 42; ❱
2096/// ❰ foo(); ❱
2097/// ❰ (); ❱
2098/// ❰ {}; ❱
2099///
2100/// // constructions with trailing curly brace can omit the semicolon
2101/// // but only when there are satements immediately after them (this is important!)
2102/// ❰ if bool_cond { } ❱
2103/// ❰ loop {} ❱
2104/// ❰ somestatment; ❱
2105/// ```
2106///
2107/// [Reference](https://doc.rust-lang.org/reference/statements.html)
1095#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2108#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1096pub struct ExprStmt { 2109pub struct ExprStmt {
1097 pub(crate) syntax: SyntaxNode, 2110 pub(crate) syntax: SyntaxNode,
@@ -1101,7 +2114,16 @@ impl ExprStmt {
1101 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 2114 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1102 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } 2115 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
1103} 2116}
1104 2117/// Let statement.
2118///
2119/// ```
2120/// ❰ #[attr] let foo; ❱
2121/// ❰ let bar: u64; ❱
2122/// ❰ let baz = 42; ❱
2123/// ❰ let bruh: bool = true; ❱
2124/// ```
2125///
2126/// [Reference](https://doc.rust-lang.org/reference/statements.html#let-statements)
1105#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2127#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1106pub struct LetStmt { 2128pub struct LetStmt {
1107 pub(crate) syntax: SyntaxNode, 2129 pub(crate) syntax: SyntaxNode,
@@ -1115,7 +2137,18 @@ impl LetStmt {
1115 pub fn initializer(&self) -> Option<Expr> { support::child(&self.syntax) } 2137 pub fn initializer(&self) -> Option<Expr> { support::child(&self.syntax) }
1116 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } 2138 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
1117} 2139}
1118 2140/// Condition of `if` or `while` expression.
2141///
2142/// ```
2143/// if ❰ true ❱ {}
2144/// if ❰ let Pat(foo) = bar ❱ {}
2145///
2146/// while ❰ true ❱ {}
2147/// while ❰ let Pat(baz) = bruh ❱ {}
2148/// ```
2149///
2150/// [If expression reference](https://doc.rust-lang.org/reference/expressions/if-expr.html)
2151/// [While expression reference](https://doc.rust-lang.org/reference/expressions/loop-expr.html#predicate-loops)
1119#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2152#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1120pub struct Condition { 2153pub struct Condition {
1121 pub(crate) syntax: SyntaxNode, 2154 pub(crate) syntax: SyntaxNode,
@@ -1126,7 +2159,18 @@ impl Condition {
1126 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } 2159 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
1127 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 2160 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1128} 2161}
1129 2162/// Parameter list **declaration**.
2163///
2164/// ```
2165/// fn foo❰ (a: u32, b: bool) ❱ -> u32 {}
2166/// let bar = ❰ |a, b| ❱ {};
2167///
2168/// impl Baz {
2169/// fn bruh❰ (&self, a: u32) ❱ {}
2170/// }
2171/// ```
2172///
2173/// [Reference](https://doc.rust-lang.org/reference/items/functions.html)ocs to codegen script
1130#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2174#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1131pub struct ParamList { 2175pub struct ParamList {
1132 pub(crate) syntax: SyntaxNode, 2176 pub(crate) syntax: SyntaxNode,
@@ -1137,7 +2181,19 @@ impl ParamList {
1137 pub fn params(&self) -> AstChildren<Param> { support::children(&self.syntax) } 2181 pub fn params(&self) -> AstChildren<Param> { support::children(&self.syntax) }
1138 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } 2182 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1139} 2183}
1140 2184/// Self parameter **declaration**.
2185///
2186/// ```
2187/// impl Bruh {
2188/// fn foo(❰ self ❱) {}
2189/// fn bar(❰ &self ❱) {}
2190/// fn baz(❰ &mut self ❱) {}
2191/// fn blah<'a>(❰ &'a self ❱) {}
2192/// fn blin(❰ self: Box<Self> ❱) {}
2193/// }
2194/// ```
2195///
2196/// [Reference](https://doc.rust-lang.org/reference/items/functions.html)
1141#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2197#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1142pub struct SelfParam { 2198pub struct SelfParam {
1143 pub(crate) syntax: SyntaxNode, 2199 pub(crate) syntax: SyntaxNode,
@@ -1152,7 +2208,17 @@ impl SelfParam {
1152 } 2208 }
1153 pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) } 2209 pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
1154} 2210}
1155 2211/// Parameter **declaration**.
2212///
2213/// ```
2214/// fn foo(❰ #[attr] Pat(bar): Pat(u32) ❱, ❰ #[attr] _: bool ❱) {}
2215///
2216/// extern "C" {
2217/// fn bar(❰ baz: u32 ❱, ❰ ... ❱) -> u32;
2218/// }
2219/// ```
2220///
2221/// [Reference](https://doc.rust-lang.org/reference/items/functions.html)
1156#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2222#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1157pub struct Param { 2223pub struct Param {
1158 pub(crate) syntax: SyntaxNode, 2224 pub(crate) syntax: SyntaxNode,
@@ -1163,7 +2229,16 @@ impl Param {
1163 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 2229 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1164 pub fn dotdotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![...]) } 2230 pub fn dotdotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![...]) }
1165} 2231}
1166 2232/// Use declaration.
2233///
2234/// ```
2235/// ❰ #[attr] pub use foo; ❱
2236/// ❰ use bar as baz; ❱
2237/// ❰ use bruh::{self, bruuh}; ❱
2238/// ❰ use { blin::blen, blah::* };
2239/// ```
2240///
2241/// [Reference](https://doc.rust-lang.org/reference/items/use-declarations.html)
1167#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2242#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1168pub struct UseItem { 2243pub struct UseItem {
1169 pub(crate) syntax: SyntaxNode, 2244 pub(crate) syntax: SyntaxNode,
@@ -1174,7 +2249,16 @@ impl UseItem {
1174 pub fn use_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![use]) } 2249 pub fn use_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![use]) }
1175 pub fn use_tree(&self) -> Option<UseTree> { support::child(&self.syntax) } 2250 pub fn use_tree(&self) -> Option<UseTree> { support::child(&self.syntax) }
1176} 2251}
1177 2252/// Use tree.
2253///
2254/// ```
2255/// pub use ❰ foo::❰ * ❱ ❱;
2256/// use ❰ bar as baz ❱;
2257/// use ❰ bruh::bruuh::{ ❰ self ❱, ❰ blin ❱ } ❱;
2258/// use ❰ { ❰ blin::blen ❱ } ❱
2259/// ```
2260///
2261/// [Reference](https://doc.rust-lang.org/reference/items/use-declarations.html)
1178#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2262#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1179pub struct UseTree { 2263pub struct UseTree {
1180 pub(crate) syntax: SyntaxNode, 2264 pub(crate) syntax: SyntaxNode,
@@ -1185,7 +2269,16 @@ impl UseTree {
1185 pub fn use_tree_list(&self) -> Option<UseTreeList> { support::child(&self.syntax) } 2269 pub fn use_tree_list(&self) -> Option<UseTreeList> { support::child(&self.syntax) }
1186 pub fn alias(&self) -> Option<Alias> { support::child(&self.syntax) } 2270 pub fn alias(&self) -> Option<Alias> { support::child(&self.syntax) }
1187} 2271}
1188 2272/// Item alias.
2273/// Note: this is not the type alias.
2274///
2275/// ```
2276/// use foo ❰ as bar ❱;
2277/// use baz::{bruh ❰ as _ ❱};
2278/// extern crate bruuh ❰ as blin ❱;
2279/// ```
2280///
2281/// [Reference](https://doc.rust-lang.org/reference/items/use-declarations.html)
1189#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2282#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1190pub struct Alias { 2283pub struct Alias {
1191 pub(crate) syntax: SyntaxNode, 2284 pub(crate) syntax: SyntaxNode,
@@ -1194,7 +2287,14 @@ impl ast::NameOwner for Alias {}
1194impl Alias { 2287impl Alias {
1195 pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) } 2288 pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
1196} 2289}
1197 2290/// Sublist of use trees.
2291///
2292/// ```
2293/// use bruh::bruuh::❰ { ❰ self ❱, ❰ blin ❱ } ❱;
2294/// use ❰ { blin::blen::❰ {} ❱ } ❱
2295/// ```
2296///
2297/// [Reference](https://doc.rust-lang.org/reference/items/use-declarations.html)
1198#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2298#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1199pub struct UseTreeList { 2299pub struct UseTreeList {
1200 pub(crate) syntax: SyntaxNode, 2300 pub(crate) syntax: SyntaxNode,
@@ -1204,7 +2304,14 @@ impl UseTreeList {
1204 pub fn use_trees(&self) -> AstChildren<UseTree> { support::children(&self.syntax) } 2304 pub fn use_trees(&self) -> AstChildren<UseTree> { support::children(&self.syntax) }
1205 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } 2305 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
1206} 2306}
1207 2307/// Extern crate item.
2308///
2309/// ```
2310/// ❰ #[attr] pub extern crate foo; ❱
2311/// ❰ extern crate self as bar; ❱
2312/// ```
2313///
2314/// [Reference](https://doc.rust-lang.org/reference/items/extern-crates.html)
1208#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2315#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1209pub struct ExternCrateItem { 2316pub struct ExternCrateItem {
1210 pub(crate) syntax: SyntaxNode, 2317 pub(crate) syntax: SyntaxNode,
@@ -1217,7 +2324,13 @@ impl ExternCrateItem {
1217 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } 2324 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
1218 pub fn alias(&self) -> Option<Alias> { support::child(&self.syntax) } 2325 pub fn alias(&self) -> Option<Alias> { support::child(&self.syntax) }
1219} 2326}
1220 2327/// Call site arguments list.
2328///
2329/// ```
2330/// foo::<T, U>❰ (42, true) ❱;
2331/// ```
2332///
2333/// [Reference](https://doc.rust-lang.org/reference/expressions/call-expr.html)
1221#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2334#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1222pub struct ArgList { 2335pub struct ArgList {
1223 pub(crate) syntax: SyntaxNode, 2336 pub(crate) syntax: SyntaxNode,
@@ -1227,16 +2340,41 @@ impl ArgList {
1227 pub fn args(&self) -> AstChildren<Expr> { support::children(&self.syntax) } 2340 pub fn args(&self) -> AstChildren<Expr> { support::children(&self.syntax) }
1228 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } 2341 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
1229} 2342}
1230 2343/// Path to a symbol. Includes single identifier names and elaborate paths with
2344/// generic parameters.
2345///
2346/// ```
2347/// (0..10).❰ ❰ collect ❱ ::<Vec<_>> ❱();
2348/// ❰ ❰ ❰ Vec ❱ ::<u8> ❱ ::with_capacity ❱(1024);
2349/// ❰ ❰ <❰ Foo ❱ as ❰ ❰ bar ❱ ::Bar ❱> ❱ ::baz ❱();
2350/// ❰ ❰ <❰ bruh ❱> ❱ ::bruuh ❱();
2351/// ```
2352///
2353/// [Reference](https://doc.rust-lang.org/reference/paths.html)
1231#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2354#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1232pub struct Path { 2355pub struct Path {
1233 pub(crate) syntax: SyntaxNode, 2356 pub(crate) syntax: SyntaxNode,
1234} 2357}
1235impl Path { 2358impl Path {
1236 pub fn segment(&self) -> Option<PathSegment> { support::child(&self.syntax) } 2359 pub fn segment(&self) -> Option<PathSegment> { support::child(&self.syntax) }
2360 pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) }
1237 pub fn qualifier(&self) -> Option<Path> { support::child(&self.syntax) } 2361 pub fn qualifier(&self) -> Option<Path> { support::child(&self.syntax) }
1238} 2362}
1239 2363/// Segment of the path to a symbol.
2364/// Only path segment of an absolute path holds the `::` token,
2365/// all other `::` tokens that connect path segments reside under `Path` itself.`
2366///
2367/// ```
2368/// (0..10).❰ collect ❱ :: ❰ <Vec<_>> ❱();
2369/// ❰ Vec ❱ :: ❰ <u8> ❱ :: ❰ with_capacity ❱(1024);
2370/// ❰ <❰ Foo ❱ as ❰ bar ❱ :: ❰ Bar ❱> ❱ :: ❰ baz ❱();
2371/// ❰ <❰ bruh ❱> ❱ :: ❰ bruuh ❱();
2372///
2373/// // Note that only in this case `::` token is inlcuded:
2374/// ❰ ::foo ❱;
2375/// ```
2376///
2377/// [Reference](https://doc.rust-lang.org/reference/paths.html)
1240#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2378#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1241pub struct PathSegment { 2379pub struct PathSegment {
1242 pub(crate) syntax: SyntaxNode, 2380 pub(crate) syntax: SyntaxNode,
@@ -1254,7 +2392,15 @@ impl PathSegment {
1254 pub fn path_type(&self) -> Option<PathType> { support::child(&self.syntax) } 2392 pub fn path_type(&self) -> Option<PathType> { support::child(&self.syntax) }
1255 pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) } 2393 pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
1256} 2394}
1257 2395/// List of type arguments that are passed at generic instantiation site.
2396///
2397/// ```
2398/// type _ = Foo ❰ ::<'a, u64, Item = Bar, 42, {true}> ❱::Bar;
2399///
2400/// Vec❰ ::<bool> ❱::();
2401/// ```
2402///
2403/// [Reference](https://doc.rust-lang.org/reference/paths.html#paths-in-expressions)
1258#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2404#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1259pub struct TypeArgList { 2405pub struct TypeArgList {
1260 pub(crate) syntax: SyntaxNode, 2406 pub(crate) syntax: SyntaxNode,
@@ -1269,7 +2415,13 @@ impl TypeArgList {
1269 pub fn const_args(&self) -> AstChildren<ConstArg> { support::children(&self.syntax) } 2415 pub fn const_args(&self) -> AstChildren<ConstArg> { support::children(&self.syntax) }
1270 pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) } 2416 pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) }
1271} 2417}
1272 2418/// Type argument that is passed at generic instantiation site.
2419///
2420/// ```
2421/// type _ = Foo::<'a, ❰ u64 ❱, ❰ bool ❱, Item = Bar, 42>::Baz;
2422/// ```
2423///
2424/// [Reference](https://doc.rust-lang.org/reference/paths.html#paths-in-expressions)
1273#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2425#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1274pub struct TypeArg { 2426pub struct TypeArg {
1275 pub(crate) syntax: SyntaxNode, 2427 pub(crate) syntax: SyntaxNode,
@@ -1277,7 +2429,13 @@ pub struct TypeArg {
1277impl TypeArg { 2429impl TypeArg {
1278 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 2430 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
1279} 2431}
1280 2432/// Associated type argument that is passed at generic instantiation site.
2433/// ```
2434/// type Foo = Bar::<'a, u64, bool, ❰ Item = Baz ❱, 42>::Bruh;
2435///
2436/// trait Bruh<T>: Iterator<❰ Item: Debug ❱> {}
2437/// ```
2438///
1281#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2439#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1282pub struct AssocTypeArg { 2440pub struct AssocTypeArg {
1283 pub(crate) syntax: SyntaxNode, 2441 pub(crate) syntax: SyntaxNode,
@@ -1288,7 +2446,15 @@ impl AssocTypeArg {
1288 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } 2446 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
1289 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 2447 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
1290} 2448}
1291 2449/// Lifetime argument that is passed at generic instantiation site.
2450///
2451/// ```
2452/// fn foo<'a>(s: &'a str) {
2453/// bar::<❰ 'a ❱>(s);
2454/// }
2455/// ```
2456///
2457/// [Reference](https://doc.rust-lang.org/reference/paths.html#paths-in-expressions)
1292#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2458#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1293pub struct LifetimeArg { 2459pub struct LifetimeArg {
1294 pub(crate) syntax: SyntaxNode, 2460 pub(crate) syntax: SyntaxNode,
@@ -1298,24 +2464,41 @@ impl LifetimeArg {
1298 support::token(&self.syntax, T![lifetime]) 2464 support::token(&self.syntax, T![lifetime])
1299 } 2465 }
1300} 2466}
1301 2467/// Constant value argument that is passed at generic instantiation site.
2468///
2469/// ```
2470/// foo::<u32, ❰ { true } ❱>();
2471///
2472/// bar::<❰ { 2 + 2} ❱>();
2473/// ```
2474///
2475/// [RFC](https://github.com/rust-lang/rfcs/blob/master/text/2000-const-generics.md#declaring-a-const-parameter)
1302#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2476#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1303pub struct ConstArg { 2477pub struct ConstArg {
1304 pub(crate) syntax: SyntaxNode, 2478 pub(crate) syntax: SyntaxNode,
1305} 2479}
1306impl ConstArg { 2480impl ConstArg {
1307 pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) } 2481 pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) }
1308 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
1309 pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) } 2482 pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
1310} 2483}
1311 2484/// FIXME: (@edwin0cheng) Remove it to use ItemList instead
2485/// https://github.com/rust-analyzer/rust-analyzer/pull/4083#discussion_r422666243
2486///
2487/// [Reference](https://doc.rust-lang.org/reference/macros.html)
1312#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2488#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1313pub struct MacroItems { 2489pub struct MacroItems {
1314 pub(crate) syntax: SyntaxNode, 2490 pub(crate) syntax: SyntaxNode,
1315} 2491}
1316impl ast::ModuleItemOwner for MacroItems {} 2492impl ast::ModuleItemOwner for MacroItems {}
1317impl MacroItems {} 2493impl MacroItems {}
1318 2494/// FIXME: (@edwin0cheng) add some documentation here. As per the writing
2495/// of this comment this ast node is not used.
2496///
2497/// ```
2498/// // FIXME: example here
2499/// ```
2500///
2501/// [Reference](https://doc.rust-lang.org/reference/macros.html)
1319#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2502#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1320pub struct MacroStmts { 2503pub struct MacroStmts {
1321 pub(crate) syntax: SyntaxNode, 2504 pub(crate) syntax: SyntaxNode,
@@ -1324,7 +2507,18 @@ impl MacroStmts {
1324 pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) } 2507 pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) }
1325 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 2508 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
1326} 2509}
1327 2510/// List of items in an extern block.
2511///
2512/// ```
2513/// extern "C" ❰
2514/// {
2515/// fn foo();
2516/// static var: u32;
2517/// }
2518/// ❱
2519/// ```
2520///
2521/// [Reference](https://doc.rust-lang.org/reference/items/external-blocks.html)
1328#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2522#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1329pub struct ExternItemList { 2523pub struct ExternItemList {
1330 pub(crate) syntax: SyntaxNode, 2524 pub(crate) syntax: SyntaxNode,
@@ -1335,7 +2529,18 @@ impl ExternItemList {
1335 pub fn extern_items(&self) -> AstChildren<ExternItem> { support::children(&self.syntax) } 2529 pub fn extern_items(&self) -> AstChildren<ExternItem> { support::children(&self.syntax) }
1336 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } 2530 pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) }
1337} 2531}
1338 2532/// Extern block.
2533///
2534/// ```
2535/// ❰
2536/// extern "C" {
2537/// fn foo();
2538/// }
2539/// ❱
2540///
2541/// ```
2542///
2543/// [Reference](https://doc.rust-lang.org/reference/items/external-blocks.html)
1339#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2544#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1340pub struct ExternBlock { 2545pub struct ExternBlock {
1341 pub(crate) syntax: SyntaxNode, 2546 pub(crate) syntax: SyntaxNode,
@@ -1344,7 +2549,15 @@ impl ExternBlock {
1344 pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) } 2549 pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) }
1345 pub fn extern_item_list(&self) -> Option<ExternItemList> { support::child(&self.syntax) } 2550 pub fn extern_item_list(&self) -> Option<ExternItemList> { support::child(&self.syntax) }
1346} 2551}
1347 2552/// Meta item in an attribute.
2553///
2554/// ```
2555/// #[❰ bar::baz = "42" ❱]
2556/// #[❰ bruh(bruuh("true")) ❱]
2557/// struct Foo;
2558/// ```
2559///
2560/// [Reference](https://doc.rust-lang.org/reference/attributes.html?highlight=meta,item#meta-item-attribute-syntax)
1348#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2561#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1349pub struct MetaItem { 2562pub struct MetaItem {
1350 pub(crate) syntax: SyntaxNode, 2563 pub(crate) syntax: SyntaxNode,
@@ -1355,7 +2568,15 @@ impl MetaItem {
1355 pub fn attr_input(&self) -> Option<AttrInput> { support::child(&self.syntax) } 2568 pub fn attr_input(&self) -> Option<AttrInput> { support::child(&self.syntax) }
1356 pub fn nested_meta_items(&self) -> AstChildren<MetaItem> { support::children(&self.syntax) } 2569 pub fn nested_meta_items(&self) -> AstChildren<MetaItem> { support::children(&self.syntax) }
1357} 2570}
1358 2571/// Macro 2.0 definition.
2572/// Their syntax is still WIP by rustc team...
2573/// ```
2574/// ❰
2575/// macro foo { }
2576/// ❱
2577/// ```
2578///
2579/// [RFC](https://github.com/rust-lang/rfcs/blob/master/text/1584-macros.md)
1359#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2580#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1360pub struct MacroDef { 2581pub struct MacroDef {
1361 pub(crate) syntax: SyntaxNode, 2582 pub(crate) syntax: SyntaxNode,
@@ -1364,7 +2585,7 @@ impl MacroDef {
1364 pub fn name(&self) -> Option<Name> { support::child(&self.syntax) } 2585 pub fn name(&self) -> Option<Name> { support::child(&self.syntax) }
1365 pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) } 2586 pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) }
1366} 2587}
1367 2588/// Any kind of nominal type definition.
1368#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2589#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1369pub enum NominalDef { 2590pub enum NominalDef {
1370 StructDef(StructDef), 2591 StructDef(StructDef),
@@ -1374,14 +2595,14 @@ pub enum NominalDef {
1374impl ast::NameOwner for NominalDef {} 2595impl ast::NameOwner for NominalDef {}
1375impl ast::TypeParamsOwner for NominalDef {} 2596impl ast::TypeParamsOwner for NominalDef {}
1376impl ast::AttrsOwner for NominalDef {} 2597impl ast::AttrsOwner for NominalDef {}
1377 2598/// Any kind of **declared** generic parameter
1378#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2599#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1379pub enum GenericParam { 2600pub enum GenericParam {
1380 LifetimeParam(LifetimeParam), 2601 LifetimeParam(LifetimeParam),
1381 TypeParam(TypeParam), 2602 TypeParam(TypeParam),
1382 ConstParam(ConstParam), 2603 ConstParam(ConstParam),
1383} 2604}
1384 2605/// Any kind of generic argument passed at instantiation site
1385#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2606#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1386pub enum GenericArg { 2607pub enum GenericArg {
1387 LifetimeArg(LifetimeArg), 2608 LifetimeArg(LifetimeArg),
@@ -1389,7 +2610,7 @@ pub enum GenericArg {
1389 ConstArg(ConstArg), 2610 ConstArg(ConstArg),
1390 AssocTypeArg(AssocTypeArg), 2611 AssocTypeArg(AssocTypeArg),
1391} 2612}
1392 2613/// Any kind of construct valid in type context
1393#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2614#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1394pub enum TypeRef { 2615pub enum TypeRef {
1395 ParenType(ParenType), 2616 ParenType(ParenType),
@@ -1406,7 +2627,7 @@ pub enum TypeRef {
1406 ImplTraitType(ImplTraitType), 2627 ImplTraitType(ImplTraitType),
1407 DynTraitType(DynTraitType), 2628 DynTraitType(DynTraitType),
1408} 2629}
1409 2630/// Any kind of top-level item that may appear in a module
1410#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2631#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1411pub enum ModuleItem { 2632pub enum ModuleItem {
1412 StructDef(StructDef), 2633 StructDef(StructDef),
@@ -1427,7 +2648,9 @@ pub enum ModuleItem {
1427impl ast::NameOwner for ModuleItem {} 2648impl ast::NameOwner for ModuleItem {}
1428impl ast::AttrsOwner for ModuleItem {} 2649impl ast::AttrsOwner for ModuleItem {}
1429impl ast::VisibilityOwner for ModuleItem {} 2650impl ast::VisibilityOwner for ModuleItem {}
1430 2651/// Any kind of item that may appear in an impl block
2652///
2653/// // FIXME: impl blocks can also contain MacroCall
1431#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2654#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1432pub enum AssocItem { 2655pub enum AssocItem {
1433 FnDef(FnDef), 2656 FnDef(FnDef),
@@ -1436,7 +2659,9 @@ pub enum AssocItem {
1436} 2659}
1437impl ast::NameOwner for AssocItem {} 2660impl ast::NameOwner for AssocItem {}
1438impl ast::AttrsOwner for AssocItem {} 2661impl ast::AttrsOwner for AssocItem {}
1439 2662/// Any kind of item that may appear in an extern block
2663///
2664/// // FIXME: extern blocks can also contain MacroCall
1440#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2665#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1441pub enum ExternItem { 2666pub enum ExternItem {
1442 FnDef(FnDef), 2667 FnDef(FnDef),
@@ -1445,7 +2670,7 @@ pub enum ExternItem {
1445impl ast::NameOwner for ExternItem {} 2670impl ast::NameOwner for ExternItem {}
1446impl ast::AttrsOwner for ExternItem {} 2671impl ast::AttrsOwner for ExternItem {}
1447impl ast::VisibilityOwner for ExternItem {} 2672impl ast::VisibilityOwner for ExternItem {}
1448 2673/// Any kind of expression
1449#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2674#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1450pub enum Expr { 2675pub enum Expr {
1451 TupleExpr(TupleExpr), 2676 TupleExpr(TupleExpr),
@@ -1481,7 +2706,7 @@ pub enum Expr {
1481 BoxExpr(BoxExpr), 2706 BoxExpr(BoxExpr),
1482} 2707}
1483impl ast::AttrsOwner for Expr {} 2708impl ast::AttrsOwner for Expr {}
1484 2709/// Any kind of pattern
1485#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2710#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1486pub enum Pat { 2711pub enum Pat {
1487 OrPat(OrPat), 2712 OrPat(OrPat),
@@ -1500,25 +2725,28 @@ pub enum Pat {
1500 LiteralPat(LiteralPat), 2725 LiteralPat(LiteralPat),
1501 MacroPat(MacroPat), 2726 MacroPat(MacroPat),
1502} 2727}
1503 2728/// Any kind of pattern that appears directly inside of the curly
2729/// braces of a record pattern
1504#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2730#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1505pub enum RecordInnerPat { 2731pub enum RecordInnerPat {
1506 RecordFieldPat(RecordFieldPat), 2732 RecordFieldPat(RecordFieldPat),
1507 BindPat(BindPat), 2733 BindPat(BindPat),
1508} 2734}
1509 2735/// Any kind of input to an attribute
1510#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2736#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1511pub enum AttrInput { 2737pub enum AttrInput {
1512 Literal(Literal), 2738 Literal(Literal),
1513 TokenTree(TokenTree), 2739 TokenTree(TokenTree),
1514} 2740}
1515 2741/// Any kind of statement
2742/// Note: there are no empty statements, these are just represented as
2743/// bare semicolons without a dedicated statement ast node.
1516#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2744#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1517pub enum Stmt { 2745pub enum Stmt {
1518 LetStmt(LetStmt), 2746 LetStmt(LetStmt),
1519 ExprStmt(ExprStmt), 2747 ExprStmt(ExprStmt),
1520} 2748}
1521 2749/// Any kind of fields list (record or tuple field lists)
1522#[derive(Debug, Clone, PartialEq, Eq, Hash)] 2750#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1523pub enum FieldDefList { 2751pub enum FieldDefList {
1524 RecordFieldDefList(RecordFieldDefList), 2752 RecordFieldDefList(RecordFieldDefList),
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-08 17:39:18 +0000