aboutsummaryrefslogtreecommitdiff
path: root/crates/ra_syntax/src/ast/generated.rs
diff options
context:
space:
mode:
Diffstat (limited to 'crates/ra_syntax/src/ast/generated.rs')
-rw-r--r--crates/ra_syntax/src/ast/generated.rs4854
1 files changed, 5 insertions, 4849 deletions
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index 0c339b987..f5199e09f 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -1,4850 +1,6 @@
1//! Generated file, do not edit by hand, see `xtask/src/codegen` 1//! This file is actually hand-written, but the submodules are indeed generated.
2 2
3use crate::{ 3#[rustfmt::skip]
4 ast::{self, AstChildren, AstNode}, 4pub(super) mod nodes;
5 SyntaxKind::{self, *}, 5#[rustfmt::skip]
6 SyntaxNode, 6pub(super) mod tokens;
7};
8#[derive(Debug, Clone, PartialEq, Eq, Hash)]
9pub struct SourceFile {
10 pub(crate) syntax: SyntaxNode,
11}
12impl std::fmt::Display for SourceFile {
13 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
14 std::fmt::Display::fmt(self.syntax(), f)
15 }
16}
17impl AstNode for SourceFile {
18 fn can_cast(kind: SyntaxKind) -> bool {
19 match kind {
20 SOURCE_FILE => true,
21 _ => false,
22 }
23 }
24 fn cast(syntax: SyntaxNode) -> Option<Self> {
25 if Self::can_cast(syntax.kind()) {
26 Some(Self { syntax })
27 } else {
28 None
29 }
30 }
31 fn syntax(&self) -> &SyntaxNode {
32 &self.syntax
33 }
34}
35impl ast::ModuleItemOwner for SourceFile {}
36impl ast::FnDefOwner for SourceFile {}
37impl SourceFile {
38 pub fn modules(&self) -> AstChildren<Module> {
39 AstChildren::new(&self.syntax)
40 }
41}
42#[derive(Debug, Clone, PartialEq, Eq, Hash)]
43pub struct FnDef {
44 pub(crate) syntax: SyntaxNode,
45}
46impl std::fmt::Display for FnDef {
47 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
48 std::fmt::Display::fmt(self.syntax(), f)
49 }
50}
51impl AstNode for FnDef {
52 fn can_cast(kind: SyntaxKind) -> bool {
53 match kind {
54 FN_DEF => true,
55 _ => false,
56 }
57 }
58 fn cast(syntax: SyntaxNode) -> Option<Self> {
59 if Self::can_cast(syntax.kind()) {
60 Some(Self { syntax })
61 } else {
62 None
63 }
64 }
65 fn syntax(&self) -> &SyntaxNode {
66 &self.syntax
67 }
68}
69impl ast::VisibilityOwner for FnDef {}
70impl ast::NameOwner for FnDef {}
71impl ast::TypeParamsOwner for FnDef {}
72impl ast::DocCommentsOwner for FnDef {}
73impl ast::AttrsOwner for FnDef {}
74impl FnDef {
75 pub fn param_list(&self) -> Option<ParamList> {
76 AstChildren::new(&self.syntax).next()
77 }
78 pub fn ret_type(&self) -> Option<RetType> {
79 AstChildren::new(&self.syntax).next()
80 }
81 pub fn body(&self) -> Option<BlockExpr> {
82 AstChildren::new(&self.syntax).next()
83 }
84}
85#[derive(Debug, Clone, PartialEq, Eq, Hash)]
86pub struct RetType {
87 pub(crate) syntax: SyntaxNode,
88}
89impl std::fmt::Display for RetType {
90 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
91 std::fmt::Display::fmt(self.syntax(), f)
92 }
93}
94impl AstNode for RetType {
95 fn can_cast(kind: SyntaxKind) -> bool {
96 match kind {
97 RET_TYPE => true,
98 _ => false,
99 }
100 }
101 fn cast(syntax: SyntaxNode) -> Option<Self> {
102 if Self::can_cast(syntax.kind()) {
103 Some(Self { syntax })
104 } else {
105 None
106 }
107 }
108 fn syntax(&self) -> &SyntaxNode {
109 &self.syntax
110 }
111}
112impl RetType {
113 pub fn type_ref(&self) -> Option<TypeRef> {
114 AstChildren::new(&self.syntax).next()
115 }
116}
117#[derive(Debug, Clone, PartialEq, Eq, Hash)]
118pub struct StructDef {
119 pub(crate) syntax: SyntaxNode,
120}
121impl std::fmt::Display for StructDef {
122 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
123 std::fmt::Display::fmt(self.syntax(), f)
124 }
125}
126impl AstNode for StructDef {
127 fn can_cast(kind: SyntaxKind) -> bool {
128 match kind {
129 STRUCT_DEF => true,
130 _ => false,
131 }
132 }
133 fn cast(syntax: SyntaxNode) -> Option<Self> {
134 if Self::can_cast(syntax.kind()) {
135 Some(Self { syntax })
136 } else {
137 None
138 }
139 }
140 fn syntax(&self) -> &SyntaxNode {
141 &self.syntax
142 }
143}
144impl ast::VisibilityOwner for StructDef {}
145impl ast::NameOwner for StructDef {}
146impl ast::TypeParamsOwner for StructDef {}
147impl ast::AttrsOwner for StructDef {}
148impl ast::DocCommentsOwner for StructDef {}
149impl StructDef {}
150#[derive(Debug, Clone, PartialEq, Eq, Hash)]
151pub struct UnionDef {
152 pub(crate) syntax: SyntaxNode,
153}
154impl std::fmt::Display for UnionDef {
155 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
156 std::fmt::Display::fmt(self.syntax(), f)
157 }
158}
159impl AstNode for UnionDef {
160 fn can_cast(kind: SyntaxKind) -> bool {
161 match kind {
162 UNION_DEF => true,
163 _ => false,
164 }
165 }
166 fn cast(syntax: SyntaxNode) -> Option<Self> {
167 if Self::can_cast(syntax.kind()) {
168 Some(Self { syntax })
169 } else {
170 None
171 }
172 }
173 fn syntax(&self) -> &SyntaxNode {
174 &self.syntax
175 }
176}
177impl ast::VisibilityOwner for UnionDef {}
178impl ast::NameOwner for UnionDef {}
179impl ast::TypeParamsOwner for UnionDef {}
180impl ast::AttrsOwner for UnionDef {}
181impl ast::DocCommentsOwner for UnionDef {}
182impl UnionDef {
183 pub fn record_field_def_list(&self) -> Option<RecordFieldDefList> {
184 AstChildren::new(&self.syntax).next()
185 }
186}
187#[derive(Debug, Clone, PartialEq, Eq, Hash)]
188pub struct RecordFieldDefList {
189 pub(crate) syntax: SyntaxNode,
190}
191impl std::fmt::Display for RecordFieldDefList {
192 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
193 std::fmt::Display::fmt(self.syntax(), f)
194 }
195}
196impl AstNode for RecordFieldDefList {
197 fn can_cast(kind: SyntaxKind) -> bool {
198 match kind {
199 RECORD_FIELD_DEF_LIST => true,
200 _ => false,
201 }
202 }
203 fn cast(syntax: SyntaxNode) -> Option<Self> {
204 if Self::can_cast(syntax.kind()) {
205 Some(Self { syntax })
206 } else {
207 None
208 }
209 }
210 fn syntax(&self) -> &SyntaxNode {
211 &self.syntax
212 }
213}
214impl RecordFieldDefList {
215 pub fn fields(&self) -> AstChildren<RecordFieldDef> {
216 AstChildren::new(&self.syntax)
217 }
218}
219#[derive(Debug, Clone, PartialEq, Eq, Hash)]
220pub struct RecordFieldDef {
221 pub(crate) syntax: SyntaxNode,
222}
223impl std::fmt::Display for RecordFieldDef {
224 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
225 std::fmt::Display::fmt(self.syntax(), f)
226 }
227}
228impl AstNode for RecordFieldDef {
229 fn can_cast(kind: SyntaxKind) -> bool {
230 match kind {
231 RECORD_FIELD_DEF => true,
232 _ => false,
233 }
234 }
235 fn cast(syntax: SyntaxNode) -> Option<Self> {
236 if Self::can_cast(syntax.kind()) {
237 Some(Self { syntax })
238 } else {
239 None
240 }
241 }
242 fn syntax(&self) -> &SyntaxNode {
243 &self.syntax
244 }
245}
246impl ast::VisibilityOwner for RecordFieldDef {}
247impl ast::NameOwner for RecordFieldDef {}
248impl ast::AttrsOwner for RecordFieldDef {}
249impl ast::DocCommentsOwner for RecordFieldDef {}
250impl ast::TypeAscriptionOwner for RecordFieldDef {}
251impl RecordFieldDef {}
252#[derive(Debug, Clone, PartialEq, Eq, Hash)]
253pub struct TupleFieldDefList {
254 pub(crate) syntax: SyntaxNode,
255}
256impl std::fmt::Display for TupleFieldDefList {
257 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
258 std::fmt::Display::fmt(self.syntax(), f)
259 }
260}
261impl AstNode for TupleFieldDefList {
262 fn can_cast(kind: SyntaxKind) -> bool {
263 match kind {
264 TUPLE_FIELD_DEF_LIST => true,
265 _ => false,
266 }
267 }
268 fn cast(syntax: SyntaxNode) -> Option<Self> {
269 if Self::can_cast(syntax.kind()) {
270 Some(Self { syntax })
271 } else {
272 None
273 }
274 }
275 fn syntax(&self) -> &SyntaxNode {
276 &self.syntax
277 }
278}
279impl TupleFieldDefList {
280 pub fn fields(&self) -> AstChildren<TupleFieldDef> {
281 AstChildren::new(&self.syntax)
282 }
283}
284#[derive(Debug, Clone, PartialEq, Eq, Hash)]
285pub struct TupleFieldDef {
286 pub(crate) syntax: SyntaxNode,
287}
288impl std::fmt::Display for TupleFieldDef {
289 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
290 std::fmt::Display::fmt(self.syntax(), f)
291 }
292}
293impl AstNode for TupleFieldDef {
294 fn can_cast(kind: SyntaxKind) -> bool {
295 match kind {
296 TUPLE_FIELD_DEF => true,
297 _ => false,
298 }
299 }
300 fn cast(syntax: SyntaxNode) -> Option<Self> {
301 if Self::can_cast(syntax.kind()) {
302 Some(Self { syntax })
303 } else {
304 None
305 }
306 }
307 fn syntax(&self) -> &SyntaxNode {
308 &self.syntax
309 }
310}
311impl ast::VisibilityOwner for TupleFieldDef {}
312impl ast::AttrsOwner for TupleFieldDef {}
313impl TupleFieldDef {
314 pub fn type_ref(&self) -> Option<TypeRef> {
315 AstChildren::new(&self.syntax).next()
316 }
317}
318#[derive(Debug, Clone, PartialEq, Eq, Hash)]
319pub struct EnumDef {
320 pub(crate) syntax: SyntaxNode,
321}
322impl std::fmt::Display for EnumDef {
323 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
324 std::fmt::Display::fmt(self.syntax(), f)
325 }
326}
327impl AstNode for EnumDef {
328 fn can_cast(kind: SyntaxKind) -> bool {
329 match kind {
330 ENUM_DEF => true,
331 _ => false,
332 }
333 }
334 fn cast(syntax: SyntaxNode) -> Option<Self> {
335 if Self::can_cast(syntax.kind()) {
336 Some(Self { syntax })
337 } else {
338 None
339 }
340 }
341 fn syntax(&self) -> &SyntaxNode {
342 &self.syntax
343 }
344}
345impl ast::VisibilityOwner for EnumDef {}
346impl ast::NameOwner for EnumDef {}
347impl ast::TypeParamsOwner for EnumDef {}
348impl ast::AttrsOwner for EnumDef {}
349impl ast::DocCommentsOwner for EnumDef {}
350impl EnumDef {
351 pub fn variant_list(&self) -> Option<EnumVariantList> {
352 AstChildren::new(&self.syntax).next()
353 }
354}
355#[derive(Debug, Clone, PartialEq, Eq, Hash)]
356pub struct EnumVariantList {
357 pub(crate) syntax: SyntaxNode,
358}
359impl std::fmt::Display for EnumVariantList {
360 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
361 std::fmt::Display::fmt(self.syntax(), f)
362 }
363}
364impl AstNode for EnumVariantList {
365 fn can_cast(kind: SyntaxKind) -> bool {
366 match kind {
367 ENUM_VARIANT_LIST => true,
368 _ => false,
369 }
370 }
371 fn cast(syntax: SyntaxNode) -> Option<Self> {
372 if Self::can_cast(syntax.kind()) {
373 Some(Self { syntax })
374 } else {
375 None
376 }
377 }
378 fn syntax(&self) -> &SyntaxNode {
379 &self.syntax
380 }
381}
382impl EnumVariantList {
383 pub fn variants(&self) -> AstChildren<EnumVariant> {
384 AstChildren::new(&self.syntax)
385 }
386}
387#[derive(Debug, Clone, PartialEq, Eq, Hash)]
388pub struct EnumVariant {
389 pub(crate) syntax: SyntaxNode,
390}
391impl std::fmt::Display for EnumVariant {
392 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
393 std::fmt::Display::fmt(self.syntax(), f)
394 }
395}
396impl AstNode for EnumVariant {
397 fn can_cast(kind: SyntaxKind) -> bool {
398 match kind {
399 ENUM_VARIANT => true,
400 _ => false,
401 }
402 }
403 fn cast(syntax: SyntaxNode) -> Option<Self> {
404 if Self::can_cast(syntax.kind()) {
405 Some(Self { syntax })
406 } else {
407 None
408 }
409 }
410 fn syntax(&self) -> &SyntaxNode {
411 &self.syntax
412 }
413}
414impl ast::NameOwner for EnumVariant {}
415impl ast::DocCommentsOwner for EnumVariant {}
416impl ast::AttrsOwner for EnumVariant {}
417impl EnumVariant {
418 pub fn expr(&self) -> Option<Expr> {
419 AstChildren::new(&self.syntax).next()
420 }
421}
422#[derive(Debug, Clone, PartialEq, Eq, Hash)]
423pub struct TraitDef {
424 pub(crate) syntax: SyntaxNode,
425}
426impl std::fmt::Display for TraitDef {
427 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
428 std::fmt::Display::fmt(self.syntax(), f)
429 }
430}
431impl AstNode for TraitDef {
432 fn can_cast(kind: SyntaxKind) -> bool {
433 match kind {
434 TRAIT_DEF => true,
435 _ => false,
436 }
437 }
438 fn cast(syntax: SyntaxNode) -> Option<Self> {
439 if Self::can_cast(syntax.kind()) {
440 Some(Self { syntax })
441 } else {
442 None
443 }
444 }
445 fn syntax(&self) -> &SyntaxNode {
446 &self.syntax
447 }
448}
449impl ast::VisibilityOwner for TraitDef {}
450impl ast::NameOwner for TraitDef {}
451impl ast::AttrsOwner for TraitDef {}
452impl ast::DocCommentsOwner for TraitDef {}
453impl ast::TypeParamsOwner for TraitDef {}
454impl ast::TypeBoundsOwner for TraitDef {}
455impl TraitDef {
456 pub fn item_list(&self) -> Option<ItemList> {
457 AstChildren::new(&self.syntax).next()
458 }
459}
460#[derive(Debug, Clone, PartialEq, Eq, Hash)]
461pub struct Module {
462 pub(crate) syntax: SyntaxNode,
463}
464impl std::fmt::Display for Module {
465 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
466 std::fmt::Display::fmt(self.syntax(), f)
467 }
468}
469impl AstNode for Module {
470 fn can_cast(kind: SyntaxKind) -> bool {
471 match kind {
472 MODULE => true,
473 _ => false,
474 }
475 }
476 fn cast(syntax: SyntaxNode) -> Option<Self> {
477 if Self::can_cast(syntax.kind()) {
478 Some(Self { syntax })
479 } else {
480 None
481 }
482 }
483 fn syntax(&self) -> &SyntaxNode {
484 &self.syntax
485 }
486}
487impl ast::VisibilityOwner for Module {}
488impl ast::NameOwner for Module {}
489impl ast::AttrsOwner for Module {}
490impl ast::DocCommentsOwner for Module {}
491impl Module {
492 pub fn item_list(&self) -> Option<ItemList> {
493 AstChildren::new(&self.syntax).next()
494 }
495}
496#[derive(Debug, Clone, PartialEq, Eq, Hash)]
497pub struct ItemList {
498 pub(crate) syntax: SyntaxNode,
499}
500impl std::fmt::Display for ItemList {
501 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
502 std::fmt::Display::fmt(self.syntax(), f)
503 }
504}
505impl AstNode for ItemList {
506 fn can_cast(kind: SyntaxKind) -> bool {
507 match kind {
508 ITEM_LIST => true,
509 _ => false,
510 }
511 }
512 fn cast(syntax: SyntaxNode) -> Option<Self> {
513 if Self::can_cast(syntax.kind()) {
514 Some(Self { syntax })
515 } else {
516 None
517 }
518 }
519 fn syntax(&self) -> &SyntaxNode {
520 &self.syntax
521 }
522}
523impl ast::FnDefOwner for ItemList {}
524impl ast::ModuleItemOwner for ItemList {}
525impl ItemList {
526 pub fn impl_items(&self) -> AstChildren<ImplItem> {
527 AstChildren::new(&self.syntax)
528 }
529}
530#[derive(Debug, Clone, PartialEq, Eq, Hash)]
531pub struct ConstDef {
532 pub(crate) syntax: SyntaxNode,
533}
534impl std::fmt::Display for ConstDef {
535 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
536 std::fmt::Display::fmt(self.syntax(), f)
537 }
538}
539impl AstNode for ConstDef {
540 fn can_cast(kind: SyntaxKind) -> bool {
541 match kind {
542 CONST_DEF => true,
543 _ => false,
544 }
545 }
546 fn cast(syntax: SyntaxNode) -> Option<Self> {
547 if Self::can_cast(syntax.kind()) {
548 Some(Self { syntax })
549 } else {
550 None
551 }
552 }
553 fn syntax(&self) -> &SyntaxNode {
554 &self.syntax
555 }
556}
557impl ast::VisibilityOwner for ConstDef {}
558impl ast::NameOwner for ConstDef {}
559impl ast::TypeParamsOwner for ConstDef {}
560impl ast::AttrsOwner for ConstDef {}
561impl ast::DocCommentsOwner for ConstDef {}
562impl ast::TypeAscriptionOwner for ConstDef {}
563impl ConstDef {
564 pub fn body(&self) -> Option<Expr> {
565 AstChildren::new(&self.syntax).next()
566 }
567}
568#[derive(Debug, Clone, PartialEq, Eq, Hash)]
569pub struct StaticDef {
570 pub(crate) syntax: SyntaxNode,
571}
572impl std::fmt::Display for StaticDef {
573 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
574 std::fmt::Display::fmt(self.syntax(), f)
575 }
576}
577impl AstNode for StaticDef {
578 fn can_cast(kind: SyntaxKind) -> bool {
579 match kind {
580 STATIC_DEF => true,
581 _ => false,
582 }
583 }
584 fn cast(syntax: SyntaxNode) -> Option<Self> {
585 if Self::can_cast(syntax.kind()) {
586 Some(Self { syntax })
587 } else {
588 None
589 }
590 }
591 fn syntax(&self) -> &SyntaxNode {
592 &self.syntax
593 }
594}
595impl ast::VisibilityOwner for StaticDef {}
596impl ast::NameOwner for StaticDef {}
597impl ast::TypeParamsOwner for StaticDef {}
598impl ast::AttrsOwner for StaticDef {}
599impl ast::DocCommentsOwner for StaticDef {}
600impl ast::TypeAscriptionOwner for StaticDef {}
601impl StaticDef {
602 pub fn body(&self) -> Option<Expr> {
603 AstChildren::new(&self.syntax).next()
604 }
605}
606#[derive(Debug, Clone, PartialEq, Eq, Hash)]
607pub struct TypeAliasDef {
608 pub(crate) syntax: SyntaxNode,
609}
610impl std::fmt::Display for TypeAliasDef {
611 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
612 std::fmt::Display::fmt(self.syntax(), f)
613 }
614}
615impl AstNode for TypeAliasDef {
616 fn can_cast(kind: SyntaxKind) -> bool {
617 match kind {
618 TYPE_ALIAS_DEF => true,
619 _ => false,
620 }
621 }
622 fn cast(syntax: SyntaxNode) -> Option<Self> {
623 if Self::can_cast(syntax.kind()) {
624 Some(Self { syntax })
625 } else {
626 None
627 }
628 }
629 fn syntax(&self) -> &SyntaxNode {
630 &self.syntax
631 }
632}
633impl ast::VisibilityOwner for TypeAliasDef {}
634impl ast::NameOwner for TypeAliasDef {}
635impl ast::TypeParamsOwner for TypeAliasDef {}
636impl ast::AttrsOwner for TypeAliasDef {}
637impl ast::DocCommentsOwner for TypeAliasDef {}
638impl ast::TypeBoundsOwner for TypeAliasDef {}
639impl TypeAliasDef {
640 pub fn type_ref(&self) -> Option<TypeRef> {
641 AstChildren::new(&self.syntax).next()
642 }
643}
644#[derive(Debug, Clone, PartialEq, Eq, Hash)]
645pub struct ImplDef {
646 pub(crate) syntax: SyntaxNode,
647}
648impl std::fmt::Display for ImplDef {
649 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
650 std::fmt::Display::fmt(self.syntax(), f)
651 }
652}
653impl AstNode for ImplDef {
654 fn can_cast(kind: SyntaxKind) -> bool {
655 match kind {
656 IMPL_DEF => true,
657 _ => false,
658 }
659 }
660 fn cast(syntax: SyntaxNode) -> Option<Self> {
661 if Self::can_cast(syntax.kind()) {
662 Some(Self { syntax })
663 } else {
664 None
665 }
666 }
667 fn syntax(&self) -> &SyntaxNode {
668 &self.syntax
669 }
670}
671impl ast::TypeParamsOwner for ImplDef {}
672impl ast::AttrsOwner for ImplDef {}
673impl ImplDef {
674 pub fn item_list(&self) -> Option<ItemList> {
675 AstChildren::new(&self.syntax).next()
676 }
677}
678#[derive(Debug, Clone, PartialEq, Eq, Hash)]
679pub struct ParenType {
680 pub(crate) syntax: SyntaxNode,
681}
682impl std::fmt::Display for ParenType {
683 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
684 std::fmt::Display::fmt(self.syntax(), f)
685 }
686}
687impl AstNode for ParenType {
688 fn can_cast(kind: SyntaxKind) -> bool {
689 match kind {
690 PAREN_TYPE => true,
691 _ => false,
692 }
693 }
694 fn cast(syntax: SyntaxNode) -> Option<Self> {
695 if Self::can_cast(syntax.kind()) {
696 Some(Self { syntax })
697 } else {
698 None
699 }
700 }
701 fn syntax(&self) -> &SyntaxNode {
702 &self.syntax
703 }
704}
705impl ParenType {
706 pub fn type_ref(&self) -> Option<TypeRef> {
707 AstChildren::new(&self.syntax).next()
708 }
709}
710#[derive(Debug, Clone, PartialEq, Eq, Hash)]
711pub struct TupleType {
712 pub(crate) syntax: SyntaxNode,
713}
714impl std::fmt::Display for TupleType {
715 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
716 std::fmt::Display::fmt(self.syntax(), f)
717 }
718}
719impl AstNode for TupleType {
720 fn can_cast(kind: SyntaxKind) -> bool {
721 match kind {
722 TUPLE_TYPE => true,
723 _ => false,
724 }
725 }
726 fn cast(syntax: SyntaxNode) -> Option<Self> {
727 if Self::can_cast(syntax.kind()) {
728 Some(Self { syntax })
729 } else {
730 None
731 }
732 }
733 fn syntax(&self) -> &SyntaxNode {
734 &self.syntax
735 }
736}
737impl TupleType {
738 pub fn fields(&self) -> AstChildren<TypeRef> {
739 AstChildren::new(&self.syntax)
740 }
741}
742#[derive(Debug, Clone, PartialEq, Eq, Hash)]
743pub struct NeverType {
744 pub(crate) syntax: SyntaxNode,
745}
746impl std::fmt::Display for NeverType {
747 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
748 std::fmt::Display::fmt(self.syntax(), f)
749 }
750}
751impl AstNode for NeverType {
752 fn can_cast(kind: SyntaxKind) -> bool {
753 match kind {
754 NEVER_TYPE => true,
755 _ => false,
756 }
757 }
758 fn cast(syntax: SyntaxNode) -> Option<Self> {
759 if Self::can_cast(syntax.kind()) {
760 Some(Self { syntax })
761 } else {
762 None
763 }
764 }
765 fn syntax(&self) -> &SyntaxNode {
766 &self.syntax
767 }
768}
769impl NeverType {}
770#[derive(Debug, Clone, PartialEq, Eq, Hash)]
771pub struct PathType {
772 pub(crate) syntax: SyntaxNode,
773}
774impl std::fmt::Display for PathType {
775 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
776 std::fmt::Display::fmt(self.syntax(), f)
777 }
778}
779impl AstNode for PathType {
780 fn can_cast(kind: SyntaxKind) -> bool {
781 match kind {
782 PATH_TYPE => true,
783 _ => false,
784 }
785 }
786 fn cast(syntax: SyntaxNode) -> Option<Self> {
787 if Self::can_cast(syntax.kind()) {
788 Some(Self { syntax })
789 } else {
790 None
791 }
792 }
793 fn syntax(&self) -> &SyntaxNode {
794 &self.syntax
795 }
796}
797impl PathType {
798 pub fn path(&self) -> Option<Path> {
799 AstChildren::new(&self.syntax).next()
800 }
801}
802#[derive(Debug, Clone, PartialEq, Eq, Hash)]
803pub struct PointerType {
804 pub(crate) syntax: SyntaxNode,
805}
806impl std::fmt::Display for PointerType {
807 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
808 std::fmt::Display::fmt(self.syntax(), f)
809 }
810}
811impl AstNode for PointerType {
812 fn can_cast(kind: SyntaxKind) -> bool {
813 match kind {
814 POINTER_TYPE => true,
815 _ => false,
816 }
817 }
818 fn cast(syntax: SyntaxNode) -> Option<Self> {
819 if Self::can_cast(syntax.kind()) {
820 Some(Self { syntax })
821 } else {
822 None
823 }
824 }
825 fn syntax(&self) -> &SyntaxNode {
826 &self.syntax
827 }
828}
829impl PointerType {
830 pub fn type_ref(&self) -> Option<TypeRef> {
831 AstChildren::new(&self.syntax).next()
832 }
833}
834#[derive(Debug, Clone, PartialEq, Eq, Hash)]
835pub struct ArrayType {
836 pub(crate) syntax: SyntaxNode,
837}
838impl std::fmt::Display for ArrayType {
839 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
840 std::fmt::Display::fmt(self.syntax(), f)
841 }
842}
843impl AstNode for ArrayType {
844 fn can_cast(kind: SyntaxKind) -> bool {
845 match kind {
846 ARRAY_TYPE => true,
847 _ => false,
848 }
849 }
850 fn cast(syntax: SyntaxNode) -> Option<Self> {
851 if Self::can_cast(syntax.kind()) {
852 Some(Self { syntax })
853 } else {
854 None
855 }
856 }
857 fn syntax(&self) -> &SyntaxNode {
858 &self.syntax
859 }
860}
861impl ArrayType {
862 pub fn type_ref(&self) -> Option<TypeRef> {
863 AstChildren::new(&self.syntax).next()
864 }
865 pub fn expr(&self) -> Option<Expr> {
866 AstChildren::new(&self.syntax).next()
867 }
868}
869#[derive(Debug, Clone, PartialEq, Eq, Hash)]
870pub struct SliceType {
871 pub(crate) syntax: SyntaxNode,
872}
873impl std::fmt::Display for SliceType {
874 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
875 std::fmt::Display::fmt(self.syntax(), f)
876 }
877}
878impl AstNode for SliceType {
879 fn can_cast(kind: SyntaxKind) -> bool {
880 match kind {
881 SLICE_TYPE => true,
882 _ => false,
883 }
884 }
885 fn cast(syntax: SyntaxNode) -> Option<Self> {
886 if Self::can_cast(syntax.kind()) {
887 Some(Self { syntax })
888 } else {
889 None
890 }
891 }
892 fn syntax(&self) -> &SyntaxNode {
893 &self.syntax
894 }
895}
896impl SliceType {
897 pub fn type_ref(&self) -> Option<TypeRef> {
898 AstChildren::new(&self.syntax).next()
899 }
900}
901#[derive(Debug, Clone, PartialEq, Eq, Hash)]
902pub struct ReferenceType {
903 pub(crate) syntax: SyntaxNode,
904}
905impl std::fmt::Display for ReferenceType {
906 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
907 std::fmt::Display::fmt(self.syntax(), f)
908 }
909}
910impl AstNode for ReferenceType {
911 fn can_cast(kind: SyntaxKind) -> bool {
912 match kind {
913 REFERENCE_TYPE => true,
914 _ => false,
915 }
916 }
917 fn cast(syntax: SyntaxNode) -> Option<Self> {
918 if Self::can_cast(syntax.kind()) {
919 Some(Self { syntax })
920 } else {
921 None
922 }
923 }
924 fn syntax(&self) -> &SyntaxNode {
925 &self.syntax
926 }
927}
928impl ReferenceType {
929 pub fn type_ref(&self) -> Option<TypeRef> {
930 AstChildren::new(&self.syntax).next()
931 }
932}
933#[derive(Debug, Clone, PartialEq, Eq, Hash)]
934pub struct PlaceholderType {
935 pub(crate) syntax: SyntaxNode,
936}
937impl std::fmt::Display for PlaceholderType {
938 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
939 std::fmt::Display::fmt(self.syntax(), f)
940 }
941}
942impl AstNode for PlaceholderType {
943 fn can_cast(kind: SyntaxKind) -> bool {
944 match kind {
945 PLACEHOLDER_TYPE => true,
946 _ => false,
947 }
948 }
949 fn cast(syntax: SyntaxNode) -> Option<Self> {
950 if Self::can_cast(syntax.kind()) {
951 Some(Self { syntax })
952 } else {
953 None
954 }
955 }
956 fn syntax(&self) -> &SyntaxNode {
957 &self.syntax
958 }
959}
960impl PlaceholderType {}
961#[derive(Debug, Clone, PartialEq, Eq, Hash)]
962pub struct FnPointerType {
963 pub(crate) syntax: SyntaxNode,
964}
965impl std::fmt::Display for FnPointerType {
966 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
967 std::fmt::Display::fmt(self.syntax(), f)
968 }
969}
970impl AstNode for FnPointerType {
971 fn can_cast(kind: SyntaxKind) -> bool {
972 match kind {
973 FN_POINTER_TYPE => true,
974 _ => false,
975 }
976 }
977 fn cast(syntax: SyntaxNode) -> Option<Self> {
978 if Self::can_cast(syntax.kind()) {
979 Some(Self { syntax })
980 } else {
981 None
982 }
983 }
984 fn syntax(&self) -> &SyntaxNode {
985 &self.syntax
986 }
987}
988impl FnPointerType {
989 pub fn param_list(&self) -> Option<ParamList> {
990 AstChildren::new(&self.syntax).next()
991 }
992 pub fn ret_type(&self) -> Option<RetType> {
993 AstChildren::new(&self.syntax).next()
994 }
995}
996#[derive(Debug, Clone, PartialEq, Eq, Hash)]
997pub struct ForType {
998 pub(crate) syntax: SyntaxNode,
999}
1000impl std::fmt::Display for ForType {
1001 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1002 std::fmt::Display::fmt(self.syntax(), f)
1003 }
1004}
1005impl AstNode for ForType {
1006 fn can_cast(kind: SyntaxKind) -> bool {
1007 match kind {
1008 FOR_TYPE => true,
1009 _ => false,
1010 }
1011 }
1012 fn cast(syntax: SyntaxNode) -> Option<Self> {
1013 if Self::can_cast(syntax.kind()) {
1014 Some(Self { syntax })
1015 } else {
1016 None
1017 }
1018 }
1019 fn syntax(&self) -> &SyntaxNode {
1020 &self.syntax
1021 }
1022}
1023impl ForType {
1024 pub fn type_ref(&self) -> Option<TypeRef> {
1025 AstChildren::new(&self.syntax).next()
1026 }
1027}
1028#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1029pub struct ImplTraitType {
1030 pub(crate) syntax: SyntaxNode,
1031}
1032impl std::fmt::Display for ImplTraitType {
1033 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1034 std::fmt::Display::fmt(self.syntax(), f)
1035 }
1036}
1037impl AstNode for ImplTraitType {
1038 fn can_cast(kind: SyntaxKind) -> bool {
1039 match kind {
1040 IMPL_TRAIT_TYPE => true,
1041 _ => false,
1042 }
1043 }
1044 fn cast(syntax: SyntaxNode) -> Option<Self> {
1045 if Self::can_cast(syntax.kind()) {
1046 Some(Self { syntax })
1047 } else {
1048 None
1049 }
1050 }
1051 fn syntax(&self) -> &SyntaxNode {
1052 &self.syntax
1053 }
1054}
1055impl ast::TypeBoundsOwner for ImplTraitType {}
1056impl ImplTraitType {}
1057#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1058pub struct DynTraitType {
1059 pub(crate) syntax: SyntaxNode,
1060}
1061impl std::fmt::Display for DynTraitType {
1062 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1063 std::fmt::Display::fmt(self.syntax(), f)
1064 }
1065}
1066impl AstNode for DynTraitType {
1067 fn can_cast(kind: SyntaxKind) -> bool {
1068 match kind {
1069 DYN_TRAIT_TYPE => true,
1070 _ => false,
1071 }
1072 }
1073 fn cast(syntax: SyntaxNode) -> Option<Self> {
1074 if Self::can_cast(syntax.kind()) {
1075 Some(Self { syntax })
1076 } else {
1077 None
1078 }
1079 }
1080 fn syntax(&self) -> &SyntaxNode {
1081 &self.syntax
1082 }
1083}
1084impl ast::TypeBoundsOwner for DynTraitType {}
1085impl DynTraitType {}
1086#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1087pub struct TupleExpr {
1088 pub(crate) syntax: SyntaxNode,
1089}
1090impl std::fmt::Display for TupleExpr {
1091 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1092 std::fmt::Display::fmt(self.syntax(), f)
1093 }
1094}
1095impl AstNode for TupleExpr {
1096 fn can_cast(kind: SyntaxKind) -> bool {
1097 match kind {
1098 TUPLE_EXPR => true,
1099 _ => false,
1100 }
1101 }
1102 fn cast(syntax: SyntaxNode) -> Option<Self> {
1103 if Self::can_cast(syntax.kind()) {
1104 Some(Self { syntax })
1105 } else {
1106 None
1107 }
1108 }
1109 fn syntax(&self) -> &SyntaxNode {
1110 &self.syntax
1111 }
1112}
1113impl TupleExpr {
1114 pub fn exprs(&self) -> AstChildren<Expr> {
1115 AstChildren::new(&self.syntax)
1116 }
1117}
1118#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1119pub struct ArrayExpr {
1120 pub(crate) syntax: SyntaxNode,
1121}
1122impl std::fmt::Display for ArrayExpr {
1123 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1124 std::fmt::Display::fmt(self.syntax(), f)
1125 }
1126}
1127impl AstNode for ArrayExpr {
1128 fn can_cast(kind: SyntaxKind) -> bool {
1129 match kind {
1130 ARRAY_EXPR => true,
1131 _ => false,
1132 }
1133 }
1134 fn cast(syntax: SyntaxNode) -> Option<Self> {
1135 if Self::can_cast(syntax.kind()) {
1136 Some(Self { syntax })
1137 } else {
1138 None
1139 }
1140 }
1141 fn syntax(&self) -> &SyntaxNode {
1142 &self.syntax
1143 }
1144}
1145impl ArrayExpr {
1146 pub fn exprs(&self) -> AstChildren<Expr> {
1147 AstChildren::new(&self.syntax)
1148 }
1149}
1150#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1151pub struct ParenExpr {
1152 pub(crate) syntax: SyntaxNode,
1153}
1154impl std::fmt::Display for ParenExpr {
1155 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1156 std::fmt::Display::fmt(self.syntax(), f)
1157 }
1158}
1159impl AstNode for ParenExpr {
1160 fn can_cast(kind: SyntaxKind) -> bool {
1161 match kind {
1162 PAREN_EXPR => true,
1163 _ => false,
1164 }
1165 }
1166 fn cast(syntax: SyntaxNode) -> Option<Self> {
1167 if Self::can_cast(syntax.kind()) {
1168 Some(Self { syntax })
1169 } else {
1170 None
1171 }
1172 }
1173 fn syntax(&self) -> &SyntaxNode {
1174 &self.syntax
1175 }
1176}
1177impl ParenExpr {
1178 pub fn expr(&self) -> Option<Expr> {
1179 AstChildren::new(&self.syntax).next()
1180 }
1181}
1182#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1183pub struct PathExpr {
1184 pub(crate) syntax: SyntaxNode,
1185}
1186impl std::fmt::Display for PathExpr {
1187 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1188 std::fmt::Display::fmt(self.syntax(), f)
1189 }
1190}
1191impl AstNode for PathExpr {
1192 fn can_cast(kind: SyntaxKind) -> bool {
1193 match kind {
1194 PATH_EXPR => true,
1195 _ => false,
1196 }
1197 }
1198 fn cast(syntax: SyntaxNode) -> Option<Self> {
1199 if Self::can_cast(syntax.kind()) {
1200 Some(Self { syntax })
1201 } else {
1202 None
1203 }
1204 }
1205 fn syntax(&self) -> &SyntaxNode {
1206 &self.syntax
1207 }
1208}
1209impl PathExpr {
1210 pub fn path(&self) -> Option<Path> {
1211 AstChildren::new(&self.syntax).next()
1212 }
1213}
1214#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1215pub struct LambdaExpr {
1216 pub(crate) syntax: SyntaxNode,
1217}
1218impl std::fmt::Display for LambdaExpr {
1219 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1220 std::fmt::Display::fmt(self.syntax(), f)
1221 }
1222}
1223impl AstNode for LambdaExpr {
1224 fn can_cast(kind: SyntaxKind) -> bool {
1225 match kind {
1226 LAMBDA_EXPR => true,
1227 _ => false,
1228 }
1229 }
1230 fn cast(syntax: SyntaxNode) -> Option<Self> {
1231 if Self::can_cast(syntax.kind()) {
1232 Some(Self { syntax })
1233 } else {
1234 None
1235 }
1236 }
1237 fn syntax(&self) -> &SyntaxNode {
1238 &self.syntax
1239 }
1240}
1241impl LambdaExpr {
1242 pub fn param_list(&self) -> Option<ParamList> {
1243 AstChildren::new(&self.syntax).next()
1244 }
1245 pub fn ret_type(&self) -> Option<RetType> {
1246 AstChildren::new(&self.syntax).next()
1247 }
1248 pub fn body(&self) -> Option<Expr> {
1249 AstChildren::new(&self.syntax).next()
1250 }
1251}
1252#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1253pub struct IfExpr {
1254 pub(crate) syntax: SyntaxNode,
1255}
1256impl std::fmt::Display for IfExpr {
1257 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1258 std::fmt::Display::fmt(self.syntax(), f)
1259 }
1260}
1261impl AstNode for IfExpr {
1262 fn can_cast(kind: SyntaxKind) -> bool {
1263 match kind {
1264 IF_EXPR => true,
1265 _ => false,
1266 }
1267 }
1268 fn cast(syntax: SyntaxNode) -> Option<Self> {
1269 if Self::can_cast(syntax.kind()) {
1270 Some(Self { syntax })
1271 } else {
1272 None
1273 }
1274 }
1275 fn syntax(&self) -> &SyntaxNode {
1276 &self.syntax
1277 }
1278}
1279impl IfExpr {
1280 pub fn condition(&self) -> Option<Condition> {
1281 AstChildren::new(&self.syntax).next()
1282 }
1283}
1284#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1285pub struct LoopExpr {
1286 pub(crate) syntax: SyntaxNode,
1287}
1288impl std::fmt::Display for LoopExpr {
1289 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1290 std::fmt::Display::fmt(self.syntax(), f)
1291 }
1292}
1293impl AstNode for LoopExpr {
1294 fn can_cast(kind: SyntaxKind) -> bool {
1295 match kind {
1296 LOOP_EXPR => true,
1297 _ => false,
1298 }
1299 }
1300 fn cast(syntax: SyntaxNode) -> Option<Self> {
1301 if Self::can_cast(syntax.kind()) {
1302 Some(Self { syntax })
1303 } else {
1304 None
1305 }
1306 }
1307 fn syntax(&self) -> &SyntaxNode {
1308 &self.syntax
1309 }
1310}
1311impl ast::LoopBodyOwner for LoopExpr {}
1312impl LoopExpr {}
1313#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1314pub struct TryBlockExpr {
1315 pub(crate) syntax: SyntaxNode,
1316}
1317impl std::fmt::Display for TryBlockExpr {
1318 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1319 std::fmt::Display::fmt(self.syntax(), f)
1320 }
1321}
1322impl AstNode for TryBlockExpr {
1323 fn can_cast(kind: SyntaxKind) -> bool {
1324 match kind {
1325 TRY_BLOCK_EXPR => true,
1326 _ => false,
1327 }
1328 }
1329 fn cast(syntax: SyntaxNode) -> Option<Self> {
1330 if Self::can_cast(syntax.kind()) {
1331 Some(Self { syntax })
1332 } else {
1333 None
1334 }
1335 }
1336 fn syntax(&self) -> &SyntaxNode {
1337 &self.syntax
1338 }
1339}
1340impl TryBlockExpr {
1341 pub fn body(&self) -> Option<BlockExpr> {
1342 AstChildren::new(&self.syntax).next()
1343 }
1344}
1345#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1346pub struct ForExpr {
1347 pub(crate) syntax: SyntaxNode,
1348}
1349impl std::fmt::Display for ForExpr {
1350 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1351 std::fmt::Display::fmt(self.syntax(), f)
1352 }
1353}
1354impl AstNode for ForExpr {
1355 fn can_cast(kind: SyntaxKind) -> bool {
1356 match kind {
1357 FOR_EXPR => true,
1358 _ => false,
1359 }
1360 }
1361 fn cast(syntax: SyntaxNode) -> Option<Self> {
1362 if Self::can_cast(syntax.kind()) {
1363 Some(Self { syntax })
1364 } else {
1365 None
1366 }
1367 }
1368 fn syntax(&self) -> &SyntaxNode {
1369 &self.syntax
1370 }
1371}
1372impl ast::LoopBodyOwner for ForExpr {}
1373impl ForExpr {
1374 pub fn pat(&self) -> Option<Pat> {
1375 AstChildren::new(&self.syntax).next()
1376 }
1377 pub fn iterable(&self) -> Option<Expr> {
1378 AstChildren::new(&self.syntax).next()
1379 }
1380}
1381#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1382pub struct WhileExpr {
1383 pub(crate) syntax: SyntaxNode,
1384}
1385impl std::fmt::Display for WhileExpr {
1386 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1387 std::fmt::Display::fmt(self.syntax(), f)
1388 }
1389}
1390impl AstNode for WhileExpr {
1391 fn can_cast(kind: SyntaxKind) -> bool {
1392 match kind {
1393 WHILE_EXPR => true,
1394 _ => false,
1395 }
1396 }
1397 fn cast(syntax: SyntaxNode) -> Option<Self> {
1398 if Self::can_cast(syntax.kind()) {
1399 Some(Self { syntax })
1400 } else {
1401 None
1402 }
1403 }
1404 fn syntax(&self) -> &SyntaxNode {
1405 &self.syntax
1406 }
1407}
1408impl ast::LoopBodyOwner for WhileExpr {}
1409impl WhileExpr {
1410 pub fn condition(&self) -> Option<Condition> {
1411 AstChildren::new(&self.syntax).next()
1412 }
1413}
1414#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1415pub struct ContinueExpr {
1416 pub(crate) syntax: SyntaxNode,
1417}
1418impl std::fmt::Display for ContinueExpr {
1419 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1420 std::fmt::Display::fmt(self.syntax(), f)
1421 }
1422}
1423impl AstNode for ContinueExpr {
1424 fn can_cast(kind: SyntaxKind) -> bool {
1425 match kind {
1426 CONTINUE_EXPR => true,
1427 _ => false,
1428 }
1429 }
1430 fn cast(syntax: SyntaxNode) -> Option<Self> {
1431 if Self::can_cast(syntax.kind()) {
1432 Some(Self { syntax })
1433 } else {
1434 None
1435 }
1436 }
1437 fn syntax(&self) -> &SyntaxNode {
1438 &self.syntax
1439 }
1440}
1441impl ContinueExpr {}
1442#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1443pub struct BreakExpr {
1444 pub(crate) syntax: SyntaxNode,
1445}
1446impl std::fmt::Display for BreakExpr {
1447 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1448 std::fmt::Display::fmt(self.syntax(), f)
1449 }
1450}
1451impl AstNode for BreakExpr {
1452 fn can_cast(kind: SyntaxKind) -> bool {
1453 match kind {
1454 BREAK_EXPR => true,
1455 _ => false,
1456 }
1457 }
1458 fn cast(syntax: SyntaxNode) -> Option<Self> {
1459 if Self::can_cast(syntax.kind()) {
1460 Some(Self { syntax })
1461 } else {
1462 None
1463 }
1464 }
1465 fn syntax(&self) -> &SyntaxNode {
1466 &self.syntax
1467 }
1468}
1469impl BreakExpr {
1470 pub fn expr(&self) -> Option<Expr> {
1471 AstChildren::new(&self.syntax).next()
1472 }
1473}
1474#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1475pub struct Label {
1476 pub(crate) syntax: SyntaxNode,
1477}
1478impl std::fmt::Display for Label {
1479 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1480 std::fmt::Display::fmt(self.syntax(), f)
1481 }
1482}
1483impl AstNode for Label {
1484 fn can_cast(kind: SyntaxKind) -> bool {
1485 match kind {
1486 LABEL => true,
1487 _ => false,
1488 }
1489 }
1490 fn cast(syntax: SyntaxNode) -> Option<Self> {
1491 if Self::can_cast(syntax.kind()) {
1492 Some(Self { syntax })
1493 } else {
1494 None
1495 }
1496 }
1497 fn syntax(&self) -> &SyntaxNode {
1498 &self.syntax
1499 }
1500}
1501impl Label {}
1502#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1503pub struct BlockExpr {
1504 pub(crate) syntax: SyntaxNode,
1505}
1506impl std::fmt::Display for BlockExpr {
1507 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1508 std::fmt::Display::fmt(self.syntax(), f)
1509 }
1510}
1511impl AstNode for BlockExpr {
1512 fn can_cast(kind: SyntaxKind) -> bool {
1513 match kind {
1514 BLOCK_EXPR => true,
1515 _ => false,
1516 }
1517 }
1518 fn cast(syntax: SyntaxNode) -> Option<Self> {
1519 if Self::can_cast(syntax.kind()) {
1520 Some(Self { syntax })
1521 } else {
1522 None
1523 }
1524 }
1525 fn syntax(&self) -> &SyntaxNode {
1526 &self.syntax
1527 }
1528}
1529impl BlockExpr {
1530 pub fn block(&self) -> Option<Block> {
1531 AstChildren::new(&self.syntax).next()
1532 }
1533}
1534#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1535pub struct ReturnExpr {
1536 pub(crate) syntax: SyntaxNode,
1537}
1538impl std::fmt::Display for ReturnExpr {
1539 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1540 std::fmt::Display::fmt(self.syntax(), f)
1541 }
1542}
1543impl AstNode for ReturnExpr {
1544 fn can_cast(kind: SyntaxKind) -> bool {
1545 match kind {
1546 RETURN_EXPR => true,
1547 _ => false,
1548 }
1549 }
1550 fn cast(syntax: SyntaxNode) -> Option<Self> {
1551 if Self::can_cast(syntax.kind()) {
1552 Some(Self { syntax })
1553 } else {
1554 None
1555 }
1556 }
1557 fn syntax(&self) -> &SyntaxNode {
1558 &self.syntax
1559 }
1560}
1561impl ReturnExpr {
1562 pub fn expr(&self) -> Option<Expr> {
1563 AstChildren::new(&self.syntax).next()
1564 }
1565}
1566#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1567pub struct CallExpr {
1568 pub(crate) syntax: SyntaxNode,
1569}
1570impl std::fmt::Display for CallExpr {
1571 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1572 std::fmt::Display::fmt(self.syntax(), f)
1573 }
1574}
1575impl AstNode for CallExpr {
1576 fn can_cast(kind: SyntaxKind) -> bool {
1577 match kind {
1578 CALL_EXPR => true,
1579 _ => false,
1580 }
1581 }
1582 fn cast(syntax: SyntaxNode) -> Option<Self> {
1583 if Self::can_cast(syntax.kind()) {
1584 Some(Self { syntax })
1585 } else {
1586 None
1587 }
1588 }
1589 fn syntax(&self) -> &SyntaxNode {
1590 &self.syntax
1591 }
1592}
1593impl ast::ArgListOwner for CallExpr {}
1594impl CallExpr {
1595 pub fn expr(&self) -> Option<Expr> {
1596 AstChildren::new(&self.syntax).next()
1597 }
1598}
1599#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1600pub struct MethodCallExpr {
1601 pub(crate) syntax: SyntaxNode,
1602}
1603impl std::fmt::Display for MethodCallExpr {
1604 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1605 std::fmt::Display::fmt(self.syntax(), f)
1606 }
1607}
1608impl AstNode for MethodCallExpr {
1609 fn can_cast(kind: SyntaxKind) -> bool {
1610 match kind {
1611 METHOD_CALL_EXPR => true,
1612 _ => false,
1613 }
1614 }
1615 fn cast(syntax: SyntaxNode) -> Option<Self> {
1616 if Self::can_cast(syntax.kind()) {
1617 Some(Self { syntax })
1618 } else {
1619 None
1620 }
1621 }
1622 fn syntax(&self) -> &SyntaxNode {
1623 &self.syntax
1624 }
1625}
1626impl ast::ArgListOwner for MethodCallExpr {}
1627impl MethodCallExpr {
1628 pub fn expr(&self) -> Option<Expr> {
1629 AstChildren::new(&self.syntax).next()
1630 }
1631 pub fn name_ref(&self) -> Option<NameRef> {
1632 AstChildren::new(&self.syntax).next()
1633 }
1634 pub fn type_arg_list(&self) -> Option<TypeArgList> {
1635 AstChildren::new(&self.syntax).next()
1636 }
1637}
1638#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1639pub struct IndexExpr {
1640 pub(crate) syntax: SyntaxNode,
1641}
1642impl std::fmt::Display for IndexExpr {
1643 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1644 std::fmt::Display::fmt(self.syntax(), f)
1645 }
1646}
1647impl AstNode for IndexExpr {
1648 fn can_cast(kind: SyntaxKind) -> bool {
1649 match kind {
1650 INDEX_EXPR => true,
1651 _ => false,
1652 }
1653 }
1654 fn cast(syntax: SyntaxNode) -> Option<Self> {
1655 if Self::can_cast(syntax.kind()) {
1656 Some(Self { syntax })
1657 } else {
1658 None
1659 }
1660 }
1661 fn syntax(&self) -> &SyntaxNode {
1662 &self.syntax
1663 }
1664}
1665impl IndexExpr {}
1666#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1667pub struct FieldExpr {
1668 pub(crate) syntax: SyntaxNode,
1669}
1670impl std::fmt::Display for FieldExpr {
1671 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1672 std::fmt::Display::fmt(self.syntax(), f)
1673 }
1674}
1675impl AstNode for FieldExpr {
1676 fn can_cast(kind: SyntaxKind) -> bool {
1677 match kind {
1678 FIELD_EXPR => true,
1679 _ => false,
1680 }
1681 }
1682 fn cast(syntax: SyntaxNode) -> Option<Self> {
1683 if Self::can_cast(syntax.kind()) {
1684 Some(Self { syntax })
1685 } else {
1686 None
1687 }
1688 }
1689 fn syntax(&self) -> &SyntaxNode {
1690 &self.syntax
1691 }
1692}
1693impl FieldExpr {
1694 pub fn expr(&self) -> Option<Expr> {
1695 AstChildren::new(&self.syntax).next()
1696 }
1697 pub fn name_ref(&self) -> Option<NameRef> {
1698 AstChildren::new(&self.syntax).next()
1699 }
1700}
1701#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1702pub struct AwaitExpr {
1703 pub(crate) syntax: SyntaxNode,
1704}
1705impl std::fmt::Display for AwaitExpr {
1706 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1707 std::fmt::Display::fmt(self.syntax(), f)
1708 }
1709}
1710impl AstNode for AwaitExpr {
1711 fn can_cast(kind: SyntaxKind) -> bool {
1712 match kind {
1713 AWAIT_EXPR => true,
1714 _ => false,
1715 }
1716 }
1717 fn cast(syntax: SyntaxNode) -> Option<Self> {
1718 if Self::can_cast(syntax.kind()) {
1719 Some(Self { syntax })
1720 } else {
1721 None
1722 }
1723 }
1724 fn syntax(&self) -> &SyntaxNode {
1725 &self.syntax
1726 }
1727}
1728impl AwaitExpr {
1729 pub fn expr(&self) -> Option<Expr> {
1730 AstChildren::new(&self.syntax).next()
1731 }
1732}
1733#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1734pub struct TryExpr {
1735 pub(crate) syntax: SyntaxNode,
1736}
1737impl std::fmt::Display for TryExpr {
1738 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1739 std::fmt::Display::fmt(self.syntax(), f)
1740 }
1741}
1742impl AstNode for TryExpr {
1743 fn can_cast(kind: SyntaxKind) -> bool {
1744 match kind {
1745 TRY_EXPR => true,
1746 _ => false,
1747 }
1748 }
1749 fn cast(syntax: SyntaxNode) -> Option<Self> {
1750 if Self::can_cast(syntax.kind()) {
1751 Some(Self { syntax })
1752 } else {
1753 None
1754 }
1755 }
1756 fn syntax(&self) -> &SyntaxNode {
1757 &self.syntax
1758 }
1759}
1760impl TryExpr {
1761 pub fn expr(&self) -> Option<Expr> {
1762 AstChildren::new(&self.syntax).next()
1763 }
1764}
1765#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1766pub struct CastExpr {
1767 pub(crate) syntax: SyntaxNode,
1768}
1769impl std::fmt::Display for CastExpr {
1770 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1771 std::fmt::Display::fmt(self.syntax(), f)
1772 }
1773}
1774impl AstNode for CastExpr {
1775 fn can_cast(kind: SyntaxKind) -> bool {
1776 match kind {
1777 CAST_EXPR => true,
1778 _ => false,
1779 }
1780 }
1781 fn cast(syntax: SyntaxNode) -> Option<Self> {
1782 if Self::can_cast(syntax.kind()) {
1783 Some(Self { syntax })
1784 } else {
1785 None
1786 }
1787 }
1788 fn syntax(&self) -> &SyntaxNode {
1789 &self.syntax
1790 }
1791}
1792impl CastExpr {
1793 pub fn expr(&self) -> Option<Expr> {
1794 AstChildren::new(&self.syntax).next()
1795 }
1796 pub fn type_ref(&self) -> Option<TypeRef> {
1797 AstChildren::new(&self.syntax).next()
1798 }
1799}
1800#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1801pub struct RefExpr {
1802 pub(crate) syntax: SyntaxNode,
1803}
1804impl std::fmt::Display for RefExpr {
1805 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1806 std::fmt::Display::fmt(self.syntax(), f)
1807 }
1808}
1809impl AstNode for RefExpr {
1810 fn can_cast(kind: SyntaxKind) -> bool {
1811 match kind {
1812 REF_EXPR => true,
1813 _ => false,
1814 }
1815 }
1816 fn cast(syntax: SyntaxNode) -> Option<Self> {
1817 if Self::can_cast(syntax.kind()) {
1818 Some(Self { syntax })
1819 } else {
1820 None
1821 }
1822 }
1823 fn syntax(&self) -> &SyntaxNode {
1824 &self.syntax
1825 }
1826}
1827impl RefExpr {
1828 pub fn expr(&self) -> Option<Expr> {
1829 AstChildren::new(&self.syntax).next()
1830 }
1831}
1832#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1833pub struct PrefixExpr {
1834 pub(crate) syntax: SyntaxNode,
1835}
1836impl std::fmt::Display for PrefixExpr {
1837 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1838 std::fmt::Display::fmt(self.syntax(), f)
1839 }
1840}
1841impl AstNode for PrefixExpr {
1842 fn can_cast(kind: SyntaxKind) -> bool {
1843 match kind {
1844 PREFIX_EXPR => true,
1845 _ => false,
1846 }
1847 }
1848 fn cast(syntax: SyntaxNode) -> Option<Self> {
1849 if Self::can_cast(syntax.kind()) {
1850 Some(Self { syntax })
1851 } else {
1852 None
1853 }
1854 }
1855 fn syntax(&self) -> &SyntaxNode {
1856 &self.syntax
1857 }
1858}
1859impl PrefixExpr {
1860 pub fn expr(&self) -> Option<Expr> {
1861 AstChildren::new(&self.syntax).next()
1862 }
1863}
1864#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1865pub struct BoxExpr {
1866 pub(crate) syntax: SyntaxNode,
1867}
1868impl std::fmt::Display for BoxExpr {
1869 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1870 std::fmt::Display::fmt(self.syntax(), f)
1871 }
1872}
1873impl AstNode for BoxExpr {
1874 fn can_cast(kind: SyntaxKind) -> bool {
1875 match kind {
1876 BOX_EXPR => true,
1877 _ => false,
1878 }
1879 }
1880 fn cast(syntax: SyntaxNode) -> Option<Self> {
1881 if Self::can_cast(syntax.kind()) {
1882 Some(Self { syntax })
1883 } else {
1884 None
1885 }
1886 }
1887 fn syntax(&self) -> &SyntaxNode {
1888 &self.syntax
1889 }
1890}
1891impl BoxExpr {
1892 pub fn expr(&self) -> Option<Expr> {
1893 AstChildren::new(&self.syntax).next()
1894 }
1895}
1896#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1897pub struct RangeExpr {
1898 pub(crate) syntax: SyntaxNode,
1899}
1900impl std::fmt::Display for RangeExpr {
1901 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1902 std::fmt::Display::fmt(self.syntax(), f)
1903 }
1904}
1905impl AstNode for RangeExpr {
1906 fn can_cast(kind: SyntaxKind) -> bool {
1907 match kind {
1908 RANGE_EXPR => true,
1909 _ => false,
1910 }
1911 }
1912 fn cast(syntax: SyntaxNode) -> Option<Self> {
1913 if Self::can_cast(syntax.kind()) {
1914 Some(Self { syntax })
1915 } else {
1916 None
1917 }
1918 }
1919 fn syntax(&self) -> &SyntaxNode {
1920 &self.syntax
1921 }
1922}
1923impl RangeExpr {}
1924#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1925pub struct BinExpr {
1926 pub(crate) syntax: SyntaxNode,
1927}
1928impl std::fmt::Display for BinExpr {
1929 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1930 std::fmt::Display::fmt(self.syntax(), f)
1931 }
1932}
1933impl AstNode for BinExpr {
1934 fn can_cast(kind: SyntaxKind) -> bool {
1935 match kind {
1936 BIN_EXPR => true,
1937 _ => false,
1938 }
1939 }
1940 fn cast(syntax: SyntaxNode) -> Option<Self> {
1941 if Self::can_cast(syntax.kind()) {
1942 Some(Self { syntax })
1943 } else {
1944 None
1945 }
1946 }
1947 fn syntax(&self) -> &SyntaxNode {
1948 &self.syntax
1949 }
1950}
1951impl BinExpr {}
1952#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1953pub struct Literal {
1954 pub(crate) syntax: SyntaxNode,
1955}
1956impl std::fmt::Display for Literal {
1957 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1958 std::fmt::Display::fmt(self.syntax(), f)
1959 }
1960}
1961impl AstNode for Literal {
1962 fn can_cast(kind: SyntaxKind) -> bool {
1963 match kind {
1964 LITERAL => true,
1965 _ => false,
1966 }
1967 }
1968 fn cast(syntax: SyntaxNode) -> Option<Self> {
1969 if Self::can_cast(syntax.kind()) {
1970 Some(Self { syntax })
1971 } else {
1972 None
1973 }
1974 }
1975 fn syntax(&self) -> &SyntaxNode {
1976 &self.syntax
1977 }
1978}
1979impl Literal {}
1980#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1981pub struct MatchExpr {
1982 pub(crate) syntax: SyntaxNode,
1983}
1984impl std::fmt::Display for MatchExpr {
1985 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1986 std::fmt::Display::fmt(self.syntax(), f)
1987 }
1988}
1989impl AstNode for MatchExpr {
1990 fn can_cast(kind: SyntaxKind) -> bool {
1991 match kind {
1992 MATCH_EXPR => true,
1993 _ => false,
1994 }
1995 }
1996 fn cast(syntax: SyntaxNode) -> Option<Self> {
1997 if Self::can_cast(syntax.kind()) {
1998 Some(Self { syntax })
1999 } else {
2000 None
2001 }
2002 }
2003 fn syntax(&self) -> &SyntaxNode {
2004 &self.syntax
2005 }
2006}
2007impl MatchExpr {
2008 pub fn expr(&self) -> Option<Expr> {
2009 AstChildren::new(&self.syntax).next()
2010 }
2011 pub fn match_arm_list(&self) -> Option<MatchArmList> {
2012 AstChildren::new(&self.syntax).next()
2013 }
2014}
2015#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2016pub struct MatchArmList {
2017 pub(crate) syntax: SyntaxNode,
2018}
2019impl std::fmt::Display for MatchArmList {
2020 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2021 std::fmt::Display::fmt(self.syntax(), f)
2022 }
2023}
2024impl AstNode for MatchArmList {
2025 fn can_cast(kind: SyntaxKind) -> bool {
2026 match kind {
2027 MATCH_ARM_LIST => true,
2028 _ => false,
2029 }
2030 }
2031 fn cast(syntax: SyntaxNode) -> Option<Self> {
2032 if Self::can_cast(syntax.kind()) {
2033 Some(Self { syntax })
2034 } else {
2035 None
2036 }
2037 }
2038 fn syntax(&self) -> &SyntaxNode {
2039 &self.syntax
2040 }
2041}
2042impl ast::AttrsOwner for MatchArmList {}
2043impl MatchArmList {
2044 pub fn arms(&self) -> AstChildren<MatchArm> {
2045 AstChildren::new(&self.syntax)
2046 }
2047}
2048#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2049pub struct MatchArm {
2050 pub(crate) syntax: SyntaxNode,
2051}
2052impl std::fmt::Display for MatchArm {
2053 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2054 std::fmt::Display::fmt(self.syntax(), f)
2055 }
2056}
2057impl AstNode for MatchArm {
2058 fn can_cast(kind: SyntaxKind) -> bool {
2059 match kind {
2060 MATCH_ARM => true,
2061 _ => false,
2062 }
2063 }
2064 fn cast(syntax: SyntaxNode) -> Option<Self> {
2065 if Self::can_cast(syntax.kind()) {
2066 Some(Self { syntax })
2067 } else {
2068 None
2069 }
2070 }
2071 fn syntax(&self) -> &SyntaxNode {
2072 &self.syntax
2073 }
2074}
2075impl ast::AttrsOwner for MatchArm {}
2076impl MatchArm {
2077 pub fn pat(&self) -> Option<Pat> {
2078 AstChildren::new(&self.syntax).next()
2079 }
2080 pub fn guard(&self) -> Option<MatchGuard> {
2081 AstChildren::new(&self.syntax).next()
2082 }
2083 pub fn expr(&self) -> Option<Expr> {
2084 AstChildren::new(&self.syntax).next()
2085 }
2086}
2087#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2088pub struct MatchGuard {
2089 pub(crate) syntax: SyntaxNode,
2090}
2091impl std::fmt::Display for MatchGuard {
2092 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2093 std::fmt::Display::fmt(self.syntax(), f)
2094 }
2095}
2096impl AstNode for MatchGuard {
2097 fn can_cast(kind: SyntaxKind) -> bool {
2098 match kind {
2099 MATCH_GUARD => true,
2100 _ => false,
2101 }
2102 }
2103 fn cast(syntax: SyntaxNode) -> Option<Self> {
2104 if Self::can_cast(syntax.kind()) {
2105 Some(Self { syntax })
2106 } else {
2107 None
2108 }
2109 }
2110 fn syntax(&self) -> &SyntaxNode {
2111 &self.syntax
2112 }
2113}
2114impl MatchGuard {
2115 pub fn expr(&self) -> Option<Expr> {
2116 AstChildren::new(&self.syntax).next()
2117 }
2118}
2119#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2120pub struct RecordLit {
2121 pub(crate) syntax: SyntaxNode,
2122}
2123impl std::fmt::Display for RecordLit {
2124 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2125 std::fmt::Display::fmt(self.syntax(), f)
2126 }
2127}
2128impl AstNode for RecordLit {
2129 fn can_cast(kind: SyntaxKind) -> bool {
2130 match kind {
2131 RECORD_LIT => true,
2132 _ => false,
2133 }
2134 }
2135 fn cast(syntax: SyntaxNode) -> Option<Self> {
2136 if Self::can_cast(syntax.kind()) {
2137 Some(Self { syntax })
2138 } else {
2139 None
2140 }
2141 }
2142 fn syntax(&self) -> &SyntaxNode {
2143 &self.syntax
2144 }
2145}
2146impl RecordLit {
2147 pub fn path(&self) -> Option<Path> {
2148 AstChildren::new(&self.syntax).next()
2149 }
2150 pub fn record_field_list(&self) -> Option<RecordFieldList> {
2151 AstChildren::new(&self.syntax).next()
2152 }
2153}
2154#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2155pub struct RecordFieldList {
2156 pub(crate) syntax: SyntaxNode,
2157}
2158impl std::fmt::Display for RecordFieldList {
2159 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2160 std::fmt::Display::fmt(self.syntax(), f)
2161 }
2162}
2163impl AstNode for RecordFieldList {
2164 fn can_cast(kind: SyntaxKind) -> bool {
2165 match kind {
2166 RECORD_FIELD_LIST => true,
2167 _ => false,
2168 }
2169 }
2170 fn cast(syntax: SyntaxNode) -> Option<Self> {
2171 if Self::can_cast(syntax.kind()) {
2172 Some(Self { syntax })
2173 } else {
2174 None
2175 }
2176 }
2177 fn syntax(&self) -> &SyntaxNode {
2178 &self.syntax
2179 }
2180}
2181impl RecordFieldList {
2182 pub fn fields(&self) -> AstChildren<RecordField> {
2183 AstChildren::new(&self.syntax)
2184 }
2185 pub fn spread(&self) -> Option<Expr> {
2186 AstChildren::new(&self.syntax).next()
2187 }
2188}
2189#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2190pub struct RecordField {
2191 pub(crate) syntax: SyntaxNode,
2192}
2193impl std::fmt::Display for RecordField {
2194 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2195 std::fmt::Display::fmt(self.syntax(), f)
2196 }
2197}
2198impl AstNode for RecordField {
2199 fn can_cast(kind: SyntaxKind) -> bool {
2200 match kind {
2201 RECORD_FIELD => true,
2202 _ => false,
2203 }
2204 }
2205 fn cast(syntax: SyntaxNode) -> Option<Self> {
2206 if Self::can_cast(syntax.kind()) {
2207 Some(Self { syntax })
2208 } else {
2209 None
2210 }
2211 }
2212 fn syntax(&self) -> &SyntaxNode {
2213 &self.syntax
2214 }
2215}
2216impl RecordField {
2217 pub fn name_ref(&self) -> Option<NameRef> {
2218 AstChildren::new(&self.syntax).next()
2219 }
2220 pub fn expr(&self) -> Option<Expr> {
2221 AstChildren::new(&self.syntax).next()
2222 }
2223}
2224#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2225pub struct OrPat {
2226 pub(crate) syntax: SyntaxNode,
2227}
2228impl std::fmt::Display for OrPat {
2229 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2230 std::fmt::Display::fmt(self.syntax(), f)
2231 }
2232}
2233impl AstNode for OrPat {
2234 fn can_cast(kind: SyntaxKind) -> bool {
2235 match kind {
2236 OR_PAT => true,
2237 _ => false,
2238 }
2239 }
2240 fn cast(syntax: SyntaxNode) -> Option<Self> {
2241 if Self::can_cast(syntax.kind()) {
2242 Some(Self { syntax })
2243 } else {
2244 None
2245 }
2246 }
2247 fn syntax(&self) -> &SyntaxNode {
2248 &self.syntax
2249 }
2250}
2251impl OrPat {
2252 pub fn pats(&self) -> AstChildren<Pat> {
2253 AstChildren::new(&self.syntax)
2254 }
2255}
2256#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2257pub struct ParenPat {
2258 pub(crate) syntax: SyntaxNode,
2259}
2260impl std::fmt::Display for ParenPat {
2261 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2262 std::fmt::Display::fmt(self.syntax(), f)
2263 }
2264}
2265impl AstNode for ParenPat {
2266 fn can_cast(kind: SyntaxKind) -> bool {
2267 match kind {
2268 PAREN_PAT => true,
2269 _ => false,
2270 }
2271 }
2272 fn cast(syntax: SyntaxNode) -> Option<Self> {
2273 if Self::can_cast(syntax.kind()) {
2274 Some(Self { syntax })
2275 } else {
2276 None
2277 }
2278 }
2279 fn syntax(&self) -> &SyntaxNode {
2280 &self.syntax
2281 }
2282}
2283impl ParenPat {
2284 pub fn pat(&self) -> Option<Pat> {
2285 AstChildren::new(&self.syntax).next()
2286 }
2287}
2288#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2289pub struct RefPat {
2290 pub(crate) syntax: SyntaxNode,
2291}
2292impl std::fmt::Display for RefPat {
2293 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2294 std::fmt::Display::fmt(self.syntax(), f)
2295 }
2296}
2297impl AstNode for RefPat {
2298 fn can_cast(kind: SyntaxKind) -> bool {
2299 match kind {
2300 REF_PAT => true,
2301 _ => false,
2302 }
2303 }
2304 fn cast(syntax: SyntaxNode) -> Option<Self> {
2305 if Self::can_cast(syntax.kind()) {
2306 Some(Self { syntax })
2307 } else {
2308 None
2309 }
2310 }
2311 fn syntax(&self) -> &SyntaxNode {
2312 &self.syntax
2313 }
2314}
2315impl RefPat {
2316 pub fn pat(&self) -> Option<Pat> {
2317 AstChildren::new(&self.syntax).next()
2318 }
2319}
2320#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2321pub struct BoxPat {
2322 pub(crate) syntax: SyntaxNode,
2323}
2324impl std::fmt::Display for BoxPat {
2325 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2326 std::fmt::Display::fmt(self.syntax(), f)
2327 }
2328}
2329impl AstNode for BoxPat {
2330 fn can_cast(kind: SyntaxKind) -> bool {
2331 match kind {
2332 BOX_PAT => true,
2333 _ => false,
2334 }
2335 }
2336 fn cast(syntax: SyntaxNode) -> Option<Self> {
2337 if Self::can_cast(syntax.kind()) {
2338 Some(Self { syntax })
2339 } else {
2340 None
2341 }
2342 }
2343 fn syntax(&self) -> &SyntaxNode {
2344 &self.syntax
2345 }
2346}
2347impl BoxPat {
2348 pub fn pat(&self) -> Option<Pat> {
2349 AstChildren::new(&self.syntax).next()
2350 }
2351}
2352#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2353pub struct BindPat {
2354 pub(crate) syntax: SyntaxNode,
2355}
2356impl std::fmt::Display for BindPat {
2357 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2358 std::fmt::Display::fmt(self.syntax(), f)
2359 }
2360}
2361impl AstNode for BindPat {
2362 fn can_cast(kind: SyntaxKind) -> bool {
2363 match kind {
2364 BIND_PAT => true,
2365 _ => false,
2366 }
2367 }
2368 fn cast(syntax: SyntaxNode) -> Option<Self> {
2369 if Self::can_cast(syntax.kind()) {
2370 Some(Self { syntax })
2371 } else {
2372 None
2373 }
2374 }
2375 fn syntax(&self) -> &SyntaxNode {
2376 &self.syntax
2377 }
2378}
2379impl ast::NameOwner for BindPat {}
2380impl BindPat {
2381 pub fn pat(&self) -> Option<Pat> {
2382 AstChildren::new(&self.syntax).next()
2383 }
2384}
2385#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2386pub struct PlaceholderPat {
2387 pub(crate) syntax: SyntaxNode,
2388}
2389impl std::fmt::Display for PlaceholderPat {
2390 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2391 std::fmt::Display::fmt(self.syntax(), f)
2392 }
2393}
2394impl AstNode for PlaceholderPat {
2395 fn can_cast(kind: SyntaxKind) -> bool {
2396 match kind {
2397 PLACEHOLDER_PAT => true,
2398 _ => false,
2399 }
2400 }
2401 fn cast(syntax: SyntaxNode) -> Option<Self> {
2402 if Self::can_cast(syntax.kind()) {
2403 Some(Self { syntax })
2404 } else {
2405 None
2406 }
2407 }
2408 fn syntax(&self) -> &SyntaxNode {
2409 &self.syntax
2410 }
2411}
2412impl PlaceholderPat {}
2413#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2414pub struct DotDotPat {
2415 pub(crate) syntax: SyntaxNode,
2416}
2417impl std::fmt::Display for DotDotPat {
2418 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2419 std::fmt::Display::fmt(self.syntax(), f)
2420 }
2421}
2422impl AstNode for DotDotPat {
2423 fn can_cast(kind: SyntaxKind) -> bool {
2424 match kind {
2425 DOT_DOT_PAT => true,
2426 _ => false,
2427 }
2428 }
2429 fn cast(syntax: SyntaxNode) -> Option<Self> {
2430 if Self::can_cast(syntax.kind()) {
2431 Some(Self { syntax })
2432 } else {
2433 None
2434 }
2435 }
2436 fn syntax(&self) -> &SyntaxNode {
2437 &self.syntax
2438 }
2439}
2440impl DotDotPat {}
2441#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2442pub struct PathPat {
2443 pub(crate) syntax: SyntaxNode,
2444}
2445impl std::fmt::Display for PathPat {
2446 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2447 std::fmt::Display::fmt(self.syntax(), f)
2448 }
2449}
2450impl AstNode for PathPat {
2451 fn can_cast(kind: SyntaxKind) -> bool {
2452 match kind {
2453 PATH_PAT => true,
2454 _ => false,
2455 }
2456 }
2457 fn cast(syntax: SyntaxNode) -> Option<Self> {
2458 if Self::can_cast(syntax.kind()) {
2459 Some(Self { syntax })
2460 } else {
2461 None
2462 }
2463 }
2464 fn syntax(&self) -> &SyntaxNode {
2465 &self.syntax
2466 }
2467}
2468impl PathPat {
2469 pub fn path(&self) -> Option<Path> {
2470 AstChildren::new(&self.syntax).next()
2471 }
2472}
2473#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2474pub struct SlicePat {
2475 pub(crate) syntax: SyntaxNode,
2476}
2477impl std::fmt::Display for SlicePat {
2478 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2479 std::fmt::Display::fmt(self.syntax(), f)
2480 }
2481}
2482impl AstNode for SlicePat {
2483 fn can_cast(kind: SyntaxKind) -> bool {
2484 match kind {
2485 SLICE_PAT => true,
2486 _ => false,
2487 }
2488 }
2489 fn cast(syntax: SyntaxNode) -> Option<Self> {
2490 if Self::can_cast(syntax.kind()) {
2491 Some(Self { syntax })
2492 } else {
2493 None
2494 }
2495 }
2496 fn syntax(&self) -> &SyntaxNode {
2497 &self.syntax
2498 }
2499}
2500impl SlicePat {
2501 pub fn args(&self) -> AstChildren<Pat> {
2502 AstChildren::new(&self.syntax)
2503 }
2504}
2505#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2506pub struct RangePat {
2507 pub(crate) syntax: SyntaxNode,
2508}
2509impl std::fmt::Display for RangePat {
2510 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2511 std::fmt::Display::fmt(self.syntax(), f)
2512 }
2513}
2514impl AstNode for RangePat {
2515 fn can_cast(kind: SyntaxKind) -> bool {
2516 match kind {
2517 RANGE_PAT => true,
2518 _ => false,
2519 }
2520 }
2521 fn cast(syntax: SyntaxNode) -> Option<Self> {
2522 if Self::can_cast(syntax.kind()) {
2523 Some(Self { syntax })
2524 } else {
2525 None
2526 }
2527 }
2528 fn syntax(&self) -> &SyntaxNode {
2529 &self.syntax
2530 }
2531}
2532impl RangePat {}
2533#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2534pub struct LiteralPat {
2535 pub(crate) syntax: SyntaxNode,
2536}
2537impl std::fmt::Display for LiteralPat {
2538 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2539 std::fmt::Display::fmt(self.syntax(), f)
2540 }
2541}
2542impl AstNode for LiteralPat {
2543 fn can_cast(kind: SyntaxKind) -> bool {
2544 match kind {
2545 LITERAL_PAT => true,
2546 _ => false,
2547 }
2548 }
2549 fn cast(syntax: SyntaxNode) -> Option<Self> {
2550 if Self::can_cast(syntax.kind()) {
2551 Some(Self { syntax })
2552 } else {
2553 None
2554 }
2555 }
2556 fn syntax(&self) -> &SyntaxNode {
2557 &self.syntax
2558 }
2559}
2560impl LiteralPat {
2561 pub fn literal(&self) -> Option<Literal> {
2562 AstChildren::new(&self.syntax).next()
2563 }
2564}
2565#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2566pub struct MacroPat {
2567 pub(crate) syntax: SyntaxNode,
2568}
2569impl std::fmt::Display for MacroPat {
2570 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2571 std::fmt::Display::fmt(self.syntax(), f)
2572 }
2573}
2574impl AstNode for MacroPat {
2575 fn can_cast(kind: SyntaxKind) -> bool {
2576 match kind {
2577 MACRO_PAT => true,
2578 _ => false,
2579 }
2580 }
2581 fn cast(syntax: SyntaxNode) -> Option<Self> {
2582 if Self::can_cast(syntax.kind()) {
2583 Some(Self { syntax })
2584 } else {
2585 None
2586 }
2587 }
2588 fn syntax(&self) -> &SyntaxNode {
2589 &self.syntax
2590 }
2591}
2592impl MacroPat {
2593 pub fn macro_call(&self) -> Option<MacroCall> {
2594 AstChildren::new(&self.syntax).next()
2595 }
2596}
2597#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2598pub struct RecordPat {
2599 pub(crate) syntax: SyntaxNode,
2600}
2601impl std::fmt::Display for RecordPat {
2602 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2603 std::fmt::Display::fmt(self.syntax(), f)
2604 }
2605}
2606impl AstNode for RecordPat {
2607 fn can_cast(kind: SyntaxKind) -> bool {
2608 match kind {
2609 RECORD_PAT => true,
2610 _ => false,
2611 }
2612 }
2613 fn cast(syntax: SyntaxNode) -> Option<Self> {
2614 if Self::can_cast(syntax.kind()) {
2615 Some(Self { syntax })
2616 } else {
2617 None
2618 }
2619 }
2620 fn syntax(&self) -> &SyntaxNode {
2621 &self.syntax
2622 }
2623}
2624impl RecordPat {
2625 pub fn record_field_pat_list(&self) -> Option<RecordFieldPatList> {
2626 AstChildren::new(&self.syntax).next()
2627 }
2628 pub fn path(&self) -> Option<Path> {
2629 AstChildren::new(&self.syntax).next()
2630 }
2631}
2632#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2633pub struct RecordFieldPatList {
2634 pub(crate) syntax: SyntaxNode,
2635}
2636impl std::fmt::Display for RecordFieldPatList {
2637 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2638 std::fmt::Display::fmt(self.syntax(), f)
2639 }
2640}
2641impl AstNode for RecordFieldPatList {
2642 fn can_cast(kind: SyntaxKind) -> bool {
2643 match kind {
2644 RECORD_FIELD_PAT_LIST => true,
2645 _ => false,
2646 }
2647 }
2648 fn cast(syntax: SyntaxNode) -> Option<Self> {
2649 if Self::can_cast(syntax.kind()) {
2650 Some(Self { syntax })
2651 } else {
2652 None
2653 }
2654 }
2655 fn syntax(&self) -> &SyntaxNode {
2656 &self.syntax
2657 }
2658}
2659impl RecordFieldPatList {
2660 pub fn record_field_pats(&self) -> AstChildren<RecordFieldPat> {
2661 AstChildren::new(&self.syntax)
2662 }
2663 pub fn bind_pats(&self) -> AstChildren<BindPat> {
2664 AstChildren::new(&self.syntax)
2665 }
2666}
2667#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2668pub struct RecordFieldPat {
2669 pub(crate) syntax: SyntaxNode,
2670}
2671impl std::fmt::Display for RecordFieldPat {
2672 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2673 std::fmt::Display::fmt(self.syntax(), f)
2674 }
2675}
2676impl AstNode for RecordFieldPat {
2677 fn can_cast(kind: SyntaxKind) -> bool {
2678 match kind {
2679 RECORD_FIELD_PAT => true,
2680 _ => false,
2681 }
2682 }
2683 fn cast(syntax: SyntaxNode) -> Option<Self> {
2684 if Self::can_cast(syntax.kind()) {
2685 Some(Self { syntax })
2686 } else {
2687 None
2688 }
2689 }
2690 fn syntax(&self) -> &SyntaxNode {
2691 &self.syntax
2692 }
2693}
2694impl ast::NameOwner for RecordFieldPat {}
2695impl RecordFieldPat {
2696 pub fn pat(&self) -> Option<Pat> {
2697 AstChildren::new(&self.syntax).next()
2698 }
2699}
2700#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2701pub struct TupleStructPat {
2702 pub(crate) syntax: SyntaxNode,
2703}
2704impl std::fmt::Display for TupleStructPat {
2705 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2706 std::fmt::Display::fmt(self.syntax(), f)
2707 }
2708}
2709impl AstNode for TupleStructPat {
2710 fn can_cast(kind: SyntaxKind) -> bool {
2711 match kind {
2712 TUPLE_STRUCT_PAT => true,
2713 _ => false,
2714 }
2715 }
2716 fn cast(syntax: SyntaxNode) -> Option<Self> {
2717 if Self::can_cast(syntax.kind()) {
2718 Some(Self { syntax })
2719 } else {
2720 None
2721 }
2722 }
2723 fn syntax(&self) -> &SyntaxNode {
2724 &self.syntax
2725 }
2726}
2727impl TupleStructPat {
2728 pub fn path(&self) -> Option<Path> {
2729 AstChildren::new(&self.syntax).next()
2730 }
2731 pub fn args(&self) -> AstChildren<Pat> {
2732 AstChildren::new(&self.syntax)
2733 }
2734}
2735#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2736pub struct TuplePat {
2737 pub(crate) syntax: SyntaxNode,
2738}
2739impl std::fmt::Display for TuplePat {
2740 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2741 std::fmt::Display::fmt(self.syntax(), f)
2742 }
2743}
2744impl AstNode for TuplePat {
2745 fn can_cast(kind: SyntaxKind) -> bool {
2746 match kind {
2747 TUPLE_PAT => true,
2748 _ => false,
2749 }
2750 }
2751 fn cast(syntax: SyntaxNode) -> Option<Self> {
2752 if Self::can_cast(syntax.kind()) {
2753 Some(Self { syntax })
2754 } else {
2755 None
2756 }
2757 }
2758 fn syntax(&self) -> &SyntaxNode {
2759 &self.syntax
2760 }
2761}
2762impl TuplePat {
2763 pub fn args(&self) -> AstChildren<Pat> {
2764 AstChildren::new(&self.syntax)
2765 }
2766}
2767#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2768pub struct Visibility {
2769 pub(crate) syntax: SyntaxNode,
2770}
2771impl std::fmt::Display for Visibility {
2772 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2773 std::fmt::Display::fmt(self.syntax(), f)
2774 }
2775}
2776impl AstNode for Visibility {
2777 fn can_cast(kind: SyntaxKind) -> bool {
2778 match kind {
2779 VISIBILITY => true,
2780 _ => false,
2781 }
2782 }
2783 fn cast(syntax: SyntaxNode) -> Option<Self> {
2784 if Self::can_cast(syntax.kind()) {
2785 Some(Self { syntax })
2786 } else {
2787 None
2788 }
2789 }
2790 fn syntax(&self) -> &SyntaxNode {
2791 &self.syntax
2792 }
2793}
2794impl Visibility {}
2795#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2796pub struct Name {
2797 pub(crate) syntax: SyntaxNode,
2798}
2799impl std::fmt::Display for Name {
2800 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2801 std::fmt::Display::fmt(self.syntax(), f)
2802 }
2803}
2804impl AstNode for Name {
2805 fn can_cast(kind: SyntaxKind) -> bool {
2806 match kind {
2807 NAME => true,
2808 _ => false,
2809 }
2810 }
2811 fn cast(syntax: SyntaxNode) -> Option<Self> {
2812 if Self::can_cast(syntax.kind()) {
2813 Some(Self { syntax })
2814 } else {
2815 None
2816 }
2817 }
2818 fn syntax(&self) -> &SyntaxNode {
2819 &self.syntax
2820 }
2821}
2822impl Name {}
2823#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2824pub struct NameRef {
2825 pub(crate) syntax: SyntaxNode,
2826}
2827impl std::fmt::Display for NameRef {
2828 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2829 std::fmt::Display::fmt(self.syntax(), f)
2830 }
2831}
2832impl AstNode for NameRef {
2833 fn can_cast(kind: SyntaxKind) -> bool {
2834 match kind {
2835 NAME_REF => true,
2836 _ => false,
2837 }
2838 }
2839 fn cast(syntax: SyntaxNode) -> Option<Self> {
2840 if Self::can_cast(syntax.kind()) {
2841 Some(Self { syntax })
2842 } else {
2843 None
2844 }
2845 }
2846 fn syntax(&self) -> &SyntaxNode {
2847 &self.syntax
2848 }
2849}
2850impl NameRef {}
2851#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2852pub struct MacroCall {
2853 pub(crate) syntax: SyntaxNode,
2854}
2855impl std::fmt::Display for MacroCall {
2856 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2857 std::fmt::Display::fmt(self.syntax(), f)
2858 }
2859}
2860impl AstNode for MacroCall {
2861 fn can_cast(kind: SyntaxKind) -> bool {
2862 match kind {
2863 MACRO_CALL => true,
2864 _ => false,
2865 }
2866 }
2867 fn cast(syntax: SyntaxNode) -> Option<Self> {
2868 if Self::can_cast(syntax.kind()) {
2869 Some(Self { syntax })
2870 } else {
2871 None
2872 }
2873 }
2874 fn syntax(&self) -> &SyntaxNode {
2875 &self.syntax
2876 }
2877}
2878impl ast::NameOwner for MacroCall {}
2879impl ast::AttrsOwner for MacroCall {}
2880impl ast::DocCommentsOwner for MacroCall {}
2881impl MacroCall {
2882 pub fn token_tree(&self) -> Option<TokenTree> {
2883 AstChildren::new(&self.syntax).next()
2884 }
2885 pub fn path(&self) -> Option<Path> {
2886 AstChildren::new(&self.syntax).next()
2887 }
2888}
2889#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2890pub struct Attr {
2891 pub(crate) syntax: SyntaxNode,
2892}
2893impl std::fmt::Display for Attr {
2894 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2895 std::fmt::Display::fmt(self.syntax(), f)
2896 }
2897}
2898impl AstNode for Attr {
2899 fn can_cast(kind: SyntaxKind) -> bool {
2900 match kind {
2901 ATTR => true,
2902 _ => false,
2903 }
2904 }
2905 fn cast(syntax: SyntaxNode) -> Option<Self> {
2906 if Self::can_cast(syntax.kind()) {
2907 Some(Self { syntax })
2908 } else {
2909 None
2910 }
2911 }
2912 fn syntax(&self) -> &SyntaxNode {
2913 &self.syntax
2914 }
2915}
2916impl Attr {
2917 pub fn path(&self) -> Option<Path> {
2918 AstChildren::new(&self.syntax).next()
2919 }
2920 pub fn input(&self) -> Option<AttrInput> {
2921 AstChildren::new(&self.syntax).next()
2922 }
2923}
2924#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2925pub struct TokenTree {
2926 pub(crate) syntax: SyntaxNode,
2927}
2928impl std::fmt::Display for TokenTree {
2929 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2930 std::fmt::Display::fmt(self.syntax(), f)
2931 }
2932}
2933impl AstNode for TokenTree {
2934 fn can_cast(kind: SyntaxKind) -> bool {
2935 match kind {
2936 TOKEN_TREE => true,
2937 _ => false,
2938 }
2939 }
2940 fn cast(syntax: SyntaxNode) -> Option<Self> {
2941 if Self::can_cast(syntax.kind()) {
2942 Some(Self { syntax })
2943 } else {
2944 None
2945 }
2946 }
2947 fn syntax(&self) -> &SyntaxNode {
2948 &self.syntax
2949 }
2950}
2951impl TokenTree {}
2952#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2953pub struct TypeParamList {
2954 pub(crate) syntax: SyntaxNode,
2955}
2956impl std::fmt::Display for TypeParamList {
2957 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2958 std::fmt::Display::fmt(self.syntax(), f)
2959 }
2960}
2961impl AstNode for TypeParamList {
2962 fn can_cast(kind: SyntaxKind) -> bool {
2963 match kind {
2964 TYPE_PARAM_LIST => true,
2965 _ => false,
2966 }
2967 }
2968 fn cast(syntax: SyntaxNode) -> Option<Self> {
2969 if Self::can_cast(syntax.kind()) {
2970 Some(Self { syntax })
2971 } else {
2972 None
2973 }
2974 }
2975 fn syntax(&self) -> &SyntaxNode {
2976 &self.syntax
2977 }
2978}
2979impl TypeParamList {
2980 pub fn type_params(&self) -> AstChildren<TypeParam> {
2981 AstChildren::new(&self.syntax)
2982 }
2983 pub fn lifetime_params(&self) -> AstChildren<LifetimeParam> {
2984 AstChildren::new(&self.syntax)
2985 }
2986}
2987#[derive(Debug, Clone, PartialEq, Eq, Hash)]
2988pub struct TypeParam {
2989 pub(crate) syntax: SyntaxNode,
2990}
2991impl std::fmt::Display for TypeParam {
2992 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
2993 std::fmt::Display::fmt(self.syntax(), f)
2994 }
2995}
2996impl AstNode for TypeParam {
2997 fn can_cast(kind: SyntaxKind) -> bool {
2998 match kind {
2999 TYPE_PARAM => true,
3000 _ => false,
3001 }
3002 }
3003 fn cast(syntax: SyntaxNode) -> Option<Self> {
3004 if Self::can_cast(syntax.kind()) {
3005 Some(Self { syntax })
3006 } else {
3007 None
3008 }
3009 }
3010 fn syntax(&self) -> &SyntaxNode {
3011 &self.syntax
3012 }
3013}
3014impl ast::NameOwner for TypeParam {}
3015impl ast::AttrsOwner for TypeParam {}
3016impl ast::TypeBoundsOwner for TypeParam {}
3017impl TypeParam {
3018 pub fn default_type(&self) -> Option<TypeRef> {
3019 AstChildren::new(&self.syntax).next()
3020 }
3021}
3022#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3023pub struct ConstParam {
3024 pub(crate) syntax: SyntaxNode,
3025}
3026impl std::fmt::Display for ConstParam {
3027 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3028 std::fmt::Display::fmt(self.syntax(), f)
3029 }
3030}
3031impl AstNode for ConstParam {
3032 fn can_cast(kind: SyntaxKind) -> bool {
3033 match kind {
3034 CONST_PARAM => true,
3035 _ => false,
3036 }
3037 }
3038 fn cast(syntax: SyntaxNode) -> Option<Self> {
3039 if Self::can_cast(syntax.kind()) {
3040 Some(Self { syntax })
3041 } else {
3042 None
3043 }
3044 }
3045 fn syntax(&self) -> &SyntaxNode {
3046 &self.syntax
3047 }
3048}
3049impl ast::NameOwner for ConstParam {}
3050impl ast::AttrsOwner for ConstParam {}
3051impl ast::TypeAscriptionOwner for ConstParam {}
3052impl ConstParam {
3053 pub fn default_val(&self) -> Option<Expr> {
3054 AstChildren::new(&self.syntax).next()
3055 }
3056}
3057#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3058pub struct LifetimeParam {
3059 pub(crate) syntax: SyntaxNode,
3060}
3061impl std::fmt::Display for LifetimeParam {
3062 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3063 std::fmt::Display::fmt(self.syntax(), f)
3064 }
3065}
3066impl AstNode for LifetimeParam {
3067 fn can_cast(kind: SyntaxKind) -> bool {
3068 match kind {
3069 LIFETIME_PARAM => true,
3070 _ => false,
3071 }
3072 }
3073 fn cast(syntax: SyntaxNode) -> Option<Self> {
3074 if Self::can_cast(syntax.kind()) {
3075 Some(Self { syntax })
3076 } else {
3077 None
3078 }
3079 }
3080 fn syntax(&self) -> &SyntaxNode {
3081 &self.syntax
3082 }
3083}
3084impl ast::AttrsOwner for LifetimeParam {}
3085impl LifetimeParam {}
3086#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3087pub struct TypeBound {
3088 pub(crate) syntax: SyntaxNode,
3089}
3090impl std::fmt::Display for TypeBound {
3091 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3092 std::fmt::Display::fmt(self.syntax(), f)
3093 }
3094}
3095impl AstNode for TypeBound {
3096 fn can_cast(kind: SyntaxKind) -> bool {
3097 match kind {
3098 TYPE_BOUND => true,
3099 _ => false,
3100 }
3101 }
3102 fn cast(syntax: SyntaxNode) -> Option<Self> {
3103 if Self::can_cast(syntax.kind()) {
3104 Some(Self { syntax })
3105 } else {
3106 None
3107 }
3108 }
3109 fn syntax(&self) -> &SyntaxNode {
3110 &self.syntax
3111 }
3112}
3113impl TypeBound {
3114 pub fn type_ref(&self) -> Option<TypeRef> {
3115 AstChildren::new(&self.syntax).next()
3116 }
3117}
3118#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3119pub struct TypeBoundList {
3120 pub(crate) syntax: SyntaxNode,
3121}
3122impl std::fmt::Display for TypeBoundList {
3123 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3124 std::fmt::Display::fmt(self.syntax(), f)
3125 }
3126}
3127impl AstNode for TypeBoundList {
3128 fn can_cast(kind: SyntaxKind) -> bool {
3129 match kind {
3130 TYPE_BOUND_LIST => true,
3131 _ => false,
3132 }
3133 }
3134 fn cast(syntax: SyntaxNode) -> Option<Self> {
3135 if Self::can_cast(syntax.kind()) {
3136 Some(Self { syntax })
3137 } else {
3138 None
3139 }
3140 }
3141 fn syntax(&self) -> &SyntaxNode {
3142 &self.syntax
3143 }
3144}
3145impl TypeBoundList {
3146 pub fn bounds(&self) -> AstChildren<TypeBound> {
3147 AstChildren::new(&self.syntax)
3148 }
3149}
3150#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3151pub struct WherePred {
3152 pub(crate) syntax: SyntaxNode,
3153}
3154impl std::fmt::Display for WherePred {
3155 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3156 std::fmt::Display::fmt(self.syntax(), f)
3157 }
3158}
3159impl AstNode for WherePred {
3160 fn can_cast(kind: SyntaxKind) -> bool {
3161 match kind {
3162 WHERE_PRED => true,
3163 _ => false,
3164 }
3165 }
3166 fn cast(syntax: SyntaxNode) -> Option<Self> {
3167 if Self::can_cast(syntax.kind()) {
3168 Some(Self { syntax })
3169 } else {
3170 None
3171 }
3172 }
3173 fn syntax(&self) -> &SyntaxNode {
3174 &self.syntax
3175 }
3176}
3177impl ast::TypeBoundsOwner for WherePred {}
3178impl WherePred {
3179 pub fn type_ref(&self) -> Option<TypeRef> {
3180 AstChildren::new(&self.syntax).next()
3181 }
3182}
3183#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3184pub struct WhereClause {
3185 pub(crate) syntax: SyntaxNode,
3186}
3187impl std::fmt::Display for WhereClause {
3188 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3189 std::fmt::Display::fmt(self.syntax(), f)
3190 }
3191}
3192impl AstNode for WhereClause {
3193 fn can_cast(kind: SyntaxKind) -> bool {
3194 match kind {
3195 WHERE_CLAUSE => true,
3196 _ => false,
3197 }
3198 }
3199 fn cast(syntax: SyntaxNode) -> Option<Self> {
3200 if Self::can_cast(syntax.kind()) {
3201 Some(Self { syntax })
3202 } else {
3203 None
3204 }
3205 }
3206 fn syntax(&self) -> &SyntaxNode {
3207 &self.syntax
3208 }
3209}
3210impl WhereClause {
3211 pub fn predicates(&self) -> AstChildren<WherePred> {
3212 AstChildren::new(&self.syntax)
3213 }
3214}
3215#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3216pub struct ExprStmt {
3217 pub(crate) syntax: SyntaxNode,
3218}
3219impl std::fmt::Display for ExprStmt {
3220 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3221 std::fmt::Display::fmt(self.syntax(), f)
3222 }
3223}
3224impl AstNode for ExprStmt {
3225 fn can_cast(kind: SyntaxKind) -> bool {
3226 match kind {
3227 EXPR_STMT => true,
3228 _ => false,
3229 }
3230 }
3231 fn cast(syntax: SyntaxNode) -> Option<Self> {
3232 if Self::can_cast(syntax.kind()) {
3233 Some(Self { syntax })
3234 } else {
3235 None
3236 }
3237 }
3238 fn syntax(&self) -> &SyntaxNode {
3239 &self.syntax
3240 }
3241}
3242impl ExprStmt {
3243 pub fn expr(&self) -> Option<Expr> {
3244 AstChildren::new(&self.syntax).next()
3245 }
3246}
3247#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3248pub struct LetStmt {
3249 pub(crate) syntax: SyntaxNode,
3250}
3251impl std::fmt::Display for LetStmt {
3252 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3253 std::fmt::Display::fmt(self.syntax(), f)
3254 }
3255}
3256impl AstNode for LetStmt {
3257 fn can_cast(kind: SyntaxKind) -> bool {
3258 match kind {
3259 LET_STMT => true,
3260 _ => false,
3261 }
3262 }
3263 fn cast(syntax: SyntaxNode) -> Option<Self> {
3264 if Self::can_cast(syntax.kind()) {
3265 Some(Self { syntax })
3266 } else {
3267 None
3268 }
3269 }
3270 fn syntax(&self) -> &SyntaxNode {
3271 &self.syntax
3272 }
3273}
3274impl ast::TypeAscriptionOwner for LetStmt {}
3275impl LetStmt {
3276 pub fn pat(&self) -> Option<Pat> {
3277 AstChildren::new(&self.syntax).next()
3278 }
3279 pub fn initializer(&self) -> Option<Expr> {
3280 AstChildren::new(&self.syntax).next()
3281 }
3282}
3283#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3284pub struct Condition {
3285 pub(crate) syntax: SyntaxNode,
3286}
3287impl std::fmt::Display for Condition {
3288 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3289 std::fmt::Display::fmt(self.syntax(), f)
3290 }
3291}
3292impl AstNode for Condition {
3293 fn can_cast(kind: SyntaxKind) -> bool {
3294 match kind {
3295 CONDITION => true,
3296 _ => false,
3297 }
3298 }
3299 fn cast(syntax: SyntaxNode) -> Option<Self> {
3300 if Self::can_cast(syntax.kind()) {
3301 Some(Self { syntax })
3302 } else {
3303 None
3304 }
3305 }
3306 fn syntax(&self) -> &SyntaxNode {
3307 &self.syntax
3308 }
3309}
3310impl Condition {
3311 pub fn pat(&self) -> Option<Pat> {
3312 AstChildren::new(&self.syntax).next()
3313 }
3314 pub fn expr(&self) -> Option<Expr> {
3315 AstChildren::new(&self.syntax).next()
3316 }
3317}
3318#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3319pub struct Block {
3320 pub(crate) syntax: SyntaxNode,
3321}
3322impl std::fmt::Display for Block {
3323 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3324 std::fmt::Display::fmt(self.syntax(), f)
3325 }
3326}
3327impl AstNode for Block {
3328 fn can_cast(kind: SyntaxKind) -> bool {
3329 match kind {
3330 BLOCK => true,
3331 _ => false,
3332 }
3333 }
3334 fn cast(syntax: SyntaxNode) -> Option<Self> {
3335 if Self::can_cast(syntax.kind()) {
3336 Some(Self { syntax })
3337 } else {
3338 None
3339 }
3340 }
3341 fn syntax(&self) -> &SyntaxNode {
3342 &self.syntax
3343 }
3344}
3345impl ast::AttrsOwner for Block {}
3346impl ast::ModuleItemOwner for Block {}
3347impl Block {
3348 pub fn statements(&self) -> AstChildren<Stmt> {
3349 AstChildren::new(&self.syntax)
3350 }
3351 pub fn expr(&self) -> Option<Expr> {
3352 AstChildren::new(&self.syntax).next()
3353 }
3354}
3355#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3356pub struct ParamList {
3357 pub(crate) syntax: SyntaxNode,
3358}
3359impl std::fmt::Display for ParamList {
3360 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3361 std::fmt::Display::fmt(self.syntax(), f)
3362 }
3363}
3364impl AstNode for ParamList {
3365 fn can_cast(kind: SyntaxKind) -> bool {
3366 match kind {
3367 PARAM_LIST => true,
3368 _ => false,
3369 }
3370 }
3371 fn cast(syntax: SyntaxNode) -> Option<Self> {
3372 if Self::can_cast(syntax.kind()) {
3373 Some(Self { syntax })
3374 } else {
3375 None
3376 }
3377 }
3378 fn syntax(&self) -> &SyntaxNode {
3379 &self.syntax
3380 }
3381}
3382impl ParamList {
3383 pub fn self_param(&self) -> Option<SelfParam> {
3384 AstChildren::new(&self.syntax).next()
3385 }
3386 pub fn params(&self) -> AstChildren<Param> {
3387 AstChildren::new(&self.syntax)
3388 }
3389}
3390#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3391pub struct SelfParam {
3392 pub(crate) syntax: SyntaxNode,
3393}
3394impl std::fmt::Display for SelfParam {
3395 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3396 std::fmt::Display::fmt(self.syntax(), f)
3397 }
3398}
3399impl AstNode for SelfParam {
3400 fn can_cast(kind: SyntaxKind) -> bool {
3401 match kind {
3402 SELF_PARAM => true,
3403 _ => false,
3404 }
3405 }
3406 fn cast(syntax: SyntaxNode) -> Option<Self> {
3407 if Self::can_cast(syntax.kind()) {
3408 Some(Self { syntax })
3409 } else {
3410 None
3411 }
3412 }
3413 fn syntax(&self) -> &SyntaxNode {
3414 &self.syntax
3415 }
3416}
3417impl ast::TypeAscriptionOwner for SelfParam {}
3418impl ast::AttrsOwner for SelfParam {}
3419impl SelfParam {}
3420#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3421pub struct Param {
3422 pub(crate) syntax: SyntaxNode,
3423}
3424impl std::fmt::Display for Param {
3425 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3426 std::fmt::Display::fmt(self.syntax(), f)
3427 }
3428}
3429impl AstNode for Param {
3430 fn can_cast(kind: SyntaxKind) -> bool {
3431 match kind {
3432 PARAM => true,
3433 _ => false,
3434 }
3435 }
3436 fn cast(syntax: SyntaxNode) -> Option<Self> {
3437 if Self::can_cast(syntax.kind()) {
3438 Some(Self { syntax })
3439 } else {
3440 None
3441 }
3442 }
3443 fn syntax(&self) -> &SyntaxNode {
3444 &self.syntax
3445 }
3446}
3447impl ast::TypeAscriptionOwner for Param {}
3448impl ast::AttrsOwner for Param {}
3449impl Param {
3450 pub fn pat(&self) -> Option<Pat> {
3451 AstChildren::new(&self.syntax).next()
3452 }
3453}
3454#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3455pub struct UseItem {
3456 pub(crate) syntax: SyntaxNode,
3457}
3458impl std::fmt::Display for UseItem {
3459 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3460 std::fmt::Display::fmt(self.syntax(), f)
3461 }
3462}
3463impl AstNode for UseItem {
3464 fn can_cast(kind: SyntaxKind) -> bool {
3465 match kind {
3466 USE_ITEM => true,
3467 _ => false,
3468 }
3469 }
3470 fn cast(syntax: SyntaxNode) -> Option<Self> {
3471 if Self::can_cast(syntax.kind()) {
3472 Some(Self { syntax })
3473 } else {
3474 None
3475 }
3476 }
3477 fn syntax(&self) -> &SyntaxNode {
3478 &self.syntax
3479 }
3480}
3481impl ast::AttrsOwner for UseItem {}
3482impl ast::VisibilityOwner for UseItem {}
3483impl UseItem {
3484 pub fn use_tree(&self) -> Option<UseTree> {
3485 AstChildren::new(&self.syntax).next()
3486 }
3487}
3488#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3489pub struct UseTree {
3490 pub(crate) syntax: SyntaxNode,
3491}
3492impl std::fmt::Display for UseTree {
3493 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3494 std::fmt::Display::fmt(self.syntax(), f)
3495 }
3496}
3497impl AstNode for UseTree {
3498 fn can_cast(kind: SyntaxKind) -> bool {
3499 match kind {
3500 USE_TREE => true,
3501 _ => false,
3502 }
3503 }
3504 fn cast(syntax: SyntaxNode) -> Option<Self> {
3505 if Self::can_cast(syntax.kind()) {
3506 Some(Self { syntax })
3507 } else {
3508 None
3509 }
3510 }
3511 fn syntax(&self) -> &SyntaxNode {
3512 &self.syntax
3513 }
3514}
3515impl UseTree {
3516 pub fn path(&self) -> Option<Path> {
3517 AstChildren::new(&self.syntax).next()
3518 }
3519 pub fn use_tree_list(&self) -> Option<UseTreeList> {
3520 AstChildren::new(&self.syntax).next()
3521 }
3522 pub fn alias(&self) -> Option<Alias> {
3523 AstChildren::new(&self.syntax).next()
3524 }
3525}
3526#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3527pub struct Alias {
3528 pub(crate) syntax: SyntaxNode,
3529}
3530impl std::fmt::Display for Alias {
3531 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3532 std::fmt::Display::fmt(self.syntax(), f)
3533 }
3534}
3535impl AstNode for Alias {
3536 fn can_cast(kind: SyntaxKind) -> bool {
3537 match kind {
3538 ALIAS => true,
3539 _ => false,
3540 }
3541 }
3542 fn cast(syntax: SyntaxNode) -> Option<Self> {
3543 if Self::can_cast(syntax.kind()) {
3544 Some(Self { syntax })
3545 } else {
3546 None
3547 }
3548 }
3549 fn syntax(&self) -> &SyntaxNode {
3550 &self.syntax
3551 }
3552}
3553impl ast::NameOwner for Alias {}
3554impl Alias {}
3555#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3556pub struct UseTreeList {
3557 pub(crate) syntax: SyntaxNode,
3558}
3559impl std::fmt::Display for UseTreeList {
3560 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3561 std::fmt::Display::fmt(self.syntax(), f)
3562 }
3563}
3564impl AstNode for UseTreeList {
3565 fn can_cast(kind: SyntaxKind) -> bool {
3566 match kind {
3567 USE_TREE_LIST => true,
3568 _ => false,
3569 }
3570 }
3571 fn cast(syntax: SyntaxNode) -> Option<Self> {
3572 if Self::can_cast(syntax.kind()) {
3573 Some(Self { syntax })
3574 } else {
3575 None
3576 }
3577 }
3578 fn syntax(&self) -> &SyntaxNode {
3579 &self.syntax
3580 }
3581}
3582impl UseTreeList {
3583 pub fn use_trees(&self) -> AstChildren<UseTree> {
3584 AstChildren::new(&self.syntax)
3585 }
3586}
3587#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3588pub struct ExternCrateItem {
3589 pub(crate) syntax: SyntaxNode,
3590}
3591impl std::fmt::Display for ExternCrateItem {
3592 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3593 std::fmt::Display::fmt(self.syntax(), f)
3594 }
3595}
3596impl AstNode for ExternCrateItem {
3597 fn can_cast(kind: SyntaxKind) -> bool {
3598 match kind {
3599 EXTERN_CRATE_ITEM => true,
3600 _ => false,
3601 }
3602 }
3603 fn cast(syntax: SyntaxNode) -> Option<Self> {
3604 if Self::can_cast(syntax.kind()) {
3605 Some(Self { syntax })
3606 } else {
3607 None
3608 }
3609 }
3610 fn syntax(&self) -> &SyntaxNode {
3611 &self.syntax
3612 }
3613}
3614impl ast::AttrsOwner for ExternCrateItem {}
3615impl ast::VisibilityOwner for ExternCrateItem {}
3616impl ExternCrateItem {
3617 pub fn name_ref(&self) -> Option<NameRef> {
3618 AstChildren::new(&self.syntax).next()
3619 }
3620 pub fn alias(&self) -> Option<Alias> {
3621 AstChildren::new(&self.syntax).next()
3622 }
3623}
3624#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3625pub struct ArgList {
3626 pub(crate) syntax: SyntaxNode,
3627}
3628impl std::fmt::Display for ArgList {
3629 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3630 std::fmt::Display::fmt(self.syntax(), f)
3631 }
3632}
3633impl AstNode for ArgList {
3634 fn can_cast(kind: SyntaxKind) -> bool {
3635 match kind {
3636 ARG_LIST => true,
3637 _ => false,
3638 }
3639 }
3640 fn cast(syntax: SyntaxNode) -> Option<Self> {
3641 if Self::can_cast(syntax.kind()) {
3642 Some(Self { syntax })
3643 } else {
3644 None
3645 }
3646 }
3647 fn syntax(&self) -> &SyntaxNode {
3648 &self.syntax
3649 }
3650}
3651impl ArgList {
3652 pub fn args(&self) -> AstChildren<Expr> {
3653 AstChildren::new(&self.syntax)
3654 }
3655}
3656#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3657pub struct Path {
3658 pub(crate) syntax: SyntaxNode,
3659}
3660impl std::fmt::Display for Path {
3661 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3662 std::fmt::Display::fmt(self.syntax(), f)
3663 }
3664}
3665impl AstNode for Path {
3666 fn can_cast(kind: SyntaxKind) -> bool {
3667 match kind {
3668 PATH => true,
3669 _ => false,
3670 }
3671 }
3672 fn cast(syntax: SyntaxNode) -> Option<Self> {
3673 if Self::can_cast(syntax.kind()) {
3674 Some(Self { syntax })
3675 } else {
3676 None
3677 }
3678 }
3679 fn syntax(&self) -> &SyntaxNode {
3680 &self.syntax
3681 }
3682}
3683impl Path {
3684 pub fn segment(&self) -> Option<PathSegment> {
3685 AstChildren::new(&self.syntax).next()
3686 }
3687 pub fn qualifier(&self) -> Option<Path> {
3688 AstChildren::new(&self.syntax).next()
3689 }
3690}
3691#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3692pub struct PathSegment {
3693 pub(crate) syntax: SyntaxNode,
3694}
3695impl std::fmt::Display for PathSegment {
3696 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3697 std::fmt::Display::fmt(self.syntax(), f)
3698 }
3699}
3700impl AstNode for PathSegment {
3701 fn can_cast(kind: SyntaxKind) -> bool {
3702 match kind {
3703 PATH_SEGMENT => true,
3704 _ => false,
3705 }
3706 }
3707 fn cast(syntax: SyntaxNode) -> Option<Self> {
3708 if Self::can_cast(syntax.kind()) {
3709 Some(Self { syntax })
3710 } else {
3711 None
3712 }
3713 }
3714 fn syntax(&self) -> &SyntaxNode {
3715 &self.syntax
3716 }
3717}
3718impl PathSegment {
3719 pub fn name_ref(&self) -> Option<NameRef> {
3720 AstChildren::new(&self.syntax).next()
3721 }
3722 pub fn type_arg_list(&self) -> Option<TypeArgList> {
3723 AstChildren::new(&self.syntax).next()
3724 }
3725 pub fn param_list(&self) -> Option<ParamList> {
3726 AstChildren::new(&self.syntax).next()
3727 }
3728 pub fn ret_type(&self) -> Option<RetType> {
3729 AstChildren::new(&self.syntax).next()
3730 }
3731 pub fn path_type(&self) -> Option<PathType> {
3732 AstChildren::new(&self.syntax).next()
3733 }
3734}
3735#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3736pub struct TypeArgList {
3737 pub(crate) syntax: SyntaxNode,
3738}
3739impl std::fmt::Display for TypeArgList {
3740 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3741 std::fmt::Display::fmt(self.syntax(), f)
3742 }
3743}
3744impl AstNode for TypeArgList {
3745 fn can_cast(kind: SyntaxKind) -> bool {
3746 match kind {
3747 TYPE_ARG_LIST => true,
3748 _ => false,
3749 }
3750 }
3751 fn cast(syntax: SyntaxNode) -> Option<Self> {
3752 if Self::can_cast(syntax.kind()) {
3753 Some(Self { syntax })
3754 } else {
3755 None
3756 }
3757 }
3758 fn syntax(&self) -> &SyntaxNode {
3759 &self.syntax
3760 }
3761}
3762impl TypeArgList {
3763 pub fn type_args(&self) -> AstChildren<TypeArg> {
3764 AstChildren::new(&self.syntax)
3765 }
3766 pub fn lifetime_args(&self) -> AstChildren<LifetimeArg> {
3767 AstChildren::new(&self.syntax)
3768 }
3769 pub fn assoc_type_args(&self) -> AstChildren<AssocTypeArg> {
3770 AstChildren::new(&self.syntax)
3771 }
3772 pub fn const_arg(&self) -> AstChildren<ConstArg> {
3773 AstChildren::new(&self.syntax)
3774 }
3775}
3776#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3777pub struct TypeArg {
3778 pub(crate) syntax: SyntaxNode,
3779}
3780impl std::fmt::Display for TypeArg {
3781 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3782 std::fmt::Display::fmt(self.syntax(), f)
3783 }
3784}
3785impl AstNode for TypeArg {
3786 fn can_cast(kind: SyntaxKind) -> bool {
3787 match kind {
3788 TYPE_ARG => true,
3789 _ => false,
3790 }
3791 }
3792 fn cast(syntax: SyntaxNode) -> Option<Self> {
3793 if Self::can_cast(syntax.kind()) {
3794 Some(Self { syntax })
3795 } else {
3796 None
3797 }
3798 }
3799 fn syntax(&self) -> &SyntaxNode {
3800 &self.syntax
3801 }
3802}
3803impl TypeArg {
3804 pub fn type_ref(&self) -> Option<TypeRef> {
3805 AstChildren::new(&self.syntax).next()
3806 }
3807}
3808#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3809pub struct AssocTypeArg {
3810 pub(crate) syntax: SyntaxNode,
3811}
3812impl std::fmt::Display for AssocTypeArg {
3813 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3814 std::fmt::Display::fmt(self.syntax(), f)
3815 }
3816}
3817impl AstNode for AssocTypeArg {
3818 fn can_cast(kind: SyntaxKind) -> bool {
3819 match kind {
3820 ASSOC_TYPE_ARG => true,
3821 _ => false,
3822 }
3823 }
3824 fn cast(syntax: SyntaxNode) -> Option<Self> {
3825 if Self::can_cast(syntax.kind()) {
3826 Some(Self { syntax })
3827 } else {
3828 None
3829 }
3830 }
3831 fn syntax(&self) -> &SyntaxNode {
3832 &self.syntax
3833 }
3834}
3835impl AssocTypeArg {
3836 pub fn name_ref(&self) -> Option<NameRef> {
3837 AstChildren::new(&self.syntax).next()
3838 }
3839 pub fn type_ref(&self) -> Option<TypeRef> {
3840 AstChildren::new(&self.syntax).next()
3841 }
3842}
3843#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3844pub struct LifetimeArg {
3845 pub(crate) syntax: SyntaxNode,
3846}
3847impl std::fmt::Display for LifetimeArg {
3848 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3849 std::fmt::Display::fmt(self.syntax(), f)
3850 }
3851}
3852impl AstNode for LifetimeArg {
3853 fn can_cast(kind: SyntaxKind) -> bool {
3854 match kind {
3855 LIFETIME_ARG => true,
3856 _ => false,
3857 }
3858 }
3859 fn cast(syntax: SyntaxNode) -> Option<Self> {
3860 if Self::can_cast(syntax.kind()) {
3861 Some(Self { syntax })
3862 } else {
3863 None
3864 }
3865 }
3866 fn syntax(&self) -> &SyntaxNode {
3867 &self.syntax
3868 }
3869}
3870impl LifetimeArg {}
3871#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3872pub struct ConstArg {
3873 pub(crate) syntax: SyntaxNode,
3874}
3875impl std::fmt::Display for ConstArg {
3876 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3877 std::fmt::Display::fmt(self.syntax(), f)
3878 }
3879}
3880impl AstNode for ConstArg {
3881 fn can_cast(kind: SyntaxKind) -> bool {
3882 match kind {
3883 CONST_ARG => true,
3884 _ => false,
3885 }
3886 }
3887 fn cast(syntax: SyntaxNode) -> Option<Self> {
3888 if Self::can_cast(syntax.kind()) {
3889 Some(Self { syntax })
3890 } else {
3891 None
3892 }
3893 }
3894 fn syntax(&self) -> &SyntaxNode {
3895 &self.syntax
3896 }
3897}
3898impl ConstArg {
3899 pub fn literal(&self) -> Option<Literal> {
3900 AstChildren::new(&self.syntax).next()
3901 }
3902 pub fn block_expr(&self) -> Option<BlockExpr> {
3903 AstChildren::new(&self.syntax).next()
3904 }
3905}
3906#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3907pub struct MacroItems {
3908 pub(crate) syntax: SyntaxNode,
3909}
3910impl std::fmt::Display for MacroItems {
3911 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3912 std::fmt::Display::fmt(self.syntax(), f)
3913 }
3914}
3915impl AstNode for MacroItems {
3916 fn can_cast(kind: SyntaxKind) -> bool {
3917 match kind {
3918 MACRO_ITEMS => true,
3919 _ => false,
3920 }
3921 }
3922 fn cast(syntax: SyntaxNode) -> Option<Self> {
3923 if Self::can_cast(syntax.kind()) {
3924 Some(Self { syntax })
3925 } else {
3926 None
3927 }
3928 }
3929 fn syntax(&self) -> &SyntaxNode {
3930 &self.syntax
3931 }
3932}
3933impl ast::ModuleItemOwner for MacroItems {}
3934impl ast::FnDefOwner for MacroItems {}
3935impl MacroItems {}
3936#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3937pub struct MacroStmts {
3938 pub(crate) syntax: SyntaxNode,
3939}
3940impl std::fmt::Display for MacroStmts {
3941 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3942 std::fmt::Display::fmt(self.syntax(), f)
3943 }
3944}
3945impl AstNode for MacroStmts {
3946 fn can_cast(kind: SyntaxKind) -> bool {
3947 match kind {
3948 MACRO_STMTS => true,
3949 _ => false,
3950 }
3951 }
3952 fn cast(syntax: SyntaxNode) -> Option<Self> {
3953 if Self::can_cast(syntax.kind()) {
3954 Some(Self { syntax })
3955 } else {
3956 None
3957 }
3958 }
3959 fn syntax(&self) -> &SyntaxNode {
3960 &self.syntax
3961 }
3962}
3963impl MacroStmts {
3964 pub fn statements(&self) -> AstChildren<Stmt> {
3965 AstChildren::new(&self.syntax)
3966 }
3967 pub fn expr(&self) -> Option<Expr> {
3968 AstChildren::new(&self.syntax).next()
3969 }
3970}
3971#[derive(Debug, Clone, PartialEq, Eq, Hash)]
3972pub enum NominalDef {
3973 StructDef(StructDef),
3974 EnumDef(EnumDef),
3975 UnionDef(UnionDef),
3976}
3977impl From<StructDef> for NominalDef {
3978 fn from(node: StructDef) -> NominalDef {
3979 NominalDef::StructDef(node)
3980 }
3981}
3982impl From<EnumDef> for NominalDef {
3983 fn from(node: EnumDef) -> NominalDef {
3984 NominalDef::EnumDef(node)
3985 }
3986}
3987impl From<UnionDef> for NominalDef {
3988 fn from(node: UnionDef) -> NominalDef {
3989 NominalDef::UnionDef(node)
3990 }
3991}
3992impl std::fmt::Display for NominalDef {
3993 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
3994 std::fmt::Display::fmt(self.syntax(), f)
3995 }
3996}
3997impl AstNode for NominalDef {
3998 fn can_cast(kind: SyntaxKind) -> bool {
3999 match kind {
4000 STRUCT_DEF | ENUM_DEF | UNION_DEF => true,
4001 _ => false,
4002 }
4003 }
4004 fn cast(syntax: SyntaxNode) -> Option<Self> {
4005 let res = match syntax.kind() {
4006 STRUCT_DEF => NominalDef::StructDef(StructDef { syntax }),
4007 ENUM_DEF => NominalDef::EnumDef(EnumDef { syntax }),
4008 UNION_DEF => NominalDef::UnionDef(UnionDef { syntax }),
4009 _ => return None,
4010 };
4011 Some(res)
4012 }
4013 fn syntax(&self) -> &SyntaxNode {
4014 match self {
4015 NominalDef::StructDef(it) => &it.syntax,
4016 NominalDef::EnumDef(it) => &it.syntax,
4017 NominalDef::UnionDef(it) => &it.syntax,
4018 }
4019 }
4020}
4021impl ast::NameOwner for NominalDef {}
4022impl ast::TypeParamsOwner for NominalDef {}
4023impl ast::AttrsOwner for NominalDef {}
4024#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4025pub enum TypeRef {
4026 ParenType(ParenType),
4027 TupleType(TupleType),
4028 NeverType(NeverType),
4029 PathType(PathType),
4030 PointerType(PointerType),
4031 ArrayType(ArrayType),
4032 SliceType(SliceType),
4033 ReferenceType(ReferenceType),
4034 PlaceholderType(PlaceholderType),
4035 FnPointerType(FnPointerType),
4036 ForType(ForType),
4037 ImplTraitType(ImplTraitType),
4038 DynTraitType(DynTraitType),
4039}
4040impl From<ParenType> for TypeRef {
4041 fn from(node: ParenType) -> TypeRef {
4042 TypeRef::ParenType(node)
4043 }
4044}
4045impl From<TupleType> for TypeRef {
4046 fn from(node: TupleType) -> TypeRef {
4047 TypeRef::TupleType(node)
4048 }
4049}
4050impl From<NeverType> for TypeRef {
4051 fn from(node: NeverType) -> TypeRef {
4052 TypeRef::NeverType(node)
4053 }
4054}
4055impl From<PathType> for TypeRef {
4056 fn from(node: PathType) -> TypeRef {
4057 TypeRef::PathType(node)
4058 }
4059}
4060impl From<PointerType> for TypeRef {
4061 fn from(node: PointerType) -> TypeRef {
4062 TypeRef::PointerType(node)
4063 }
4064}
4065impl From<ArrayType> for TypeRef {
4066 fn from(node: ArrayType) -> TypeRef {
4067 TypeRef::ArrayType(node)
4068 }
4069}
4070impl From<SliceType> for TypeRef {
4071 fn from(node: SliceType) -> TypeRef {
4072 TypeRef::SliceType(node)
4073 }
4074}
4075impl From<ReferenceType> for TypeRef {
4076 fn from(node: ReferenceType) -> TypeRef {
4077 TypeRef::ReferenceType(node)
4078 }
4079}
4080impl From<PlaceholderType> for TypeRef {
4081 fn from(node: PlaceholderType) -> TypeRef {
4082 TypeRef::PlaceholderType(node)
4083 }
4084}
4085impl From<FnPointerType> for TypeRef {
4086 fn from(node: FnPointerType) -> TypeRef {
4087 TypeRef::FnPointerType(node)
4088 }
4089}
4090impl From<ForType> for TypeRef {
4091 fn from(node: ForType) -> TypeRef {
4092 TypeRef::ForType(node)
4093 }
4094}
4095impl From<ImplTraitType> for TypeRef {
4096 fn from(node: ImplTraitType) -> TypeRef {
4097 TypeRef::ImplTraitType(node)
4098 }
4099}
4100impl From<DynTraitType> for TypeRef {
4101 fn from(node: DynTraitType) -> TypeRef {
4102 TypeRef::DynTraitType(node)
4103 }
4104}
4105impl std::fmt::Display for TypeRef {
4106 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4107 std::fmt::Display::fmt(self.syntax(), f)
4108 }
4109}
4110impl AstNode for TypeRef {
4111 fn can_cast(kind: SyntaxKind) -> bool {
4112 match kind {
4113 PAREN_TYPE | TUPLE_TYPE | NEVER_TYPE | PATH_TYPE | POINTER_TYPE | ARRAY_TYPE
4114 | SLICE_TYPE | REFERENCE_TYPE | PLACEHOLDER_TYPE | FN_POINTER_TYPE | FOR_TYPE
4115 | IMPL_TRAIT_TYPE | DYN_TRAIT_TYPE => true,
4116 _ => false,
4117 }
4118 }
4119 fn cast(syntax: SyntaxNode) -> Option<Self> {
4120 let res = match syntax.kind() {
4121 PAREN_TYPE => TypeRef::ParenType(ParenType { syntax }),
4122 TUPLE_TYPE => TypeRef::TupleType(TupleType { syntax }),
4123 NEVER_TYPE => TypeRef::NeverType(NeverType { syntax }),
4124 PATH_TYPE => TypeRef::PathType(PathType { syntax }),
4125 POINTER_TYPE => TypeRef::PointerType(PointerType { syntax }),
4126 ARRAY_TYPE => TypeRef::ArrayType(ArrayType { syntax }),
4127 SLICE_TYPE => TypeRef::SliceType(SliceType { syntax }),
4128 REFERENCE_TYPE => TypeRef::ReferenceType(ReferenceType { syntax }),
4129 PLACEHOLDER_TYPE => TypeRef::PlaceholderType(PlaceholderType { syntax }),
4130 FN_POINTER_TYPE => TypeRef::FnPointerType(FnPointerType { syntax }),
4131 FOR_TYPE => TypeRef::ForType(ForType { syntax }),
4132 IMPL_TRAIT_TYPE => TypeRef::ImplTraitType(ImplTraitType { syntax }),
4133 DYN_TRAIT_TYPE => TypeRef::DynTraitType(DynTraitType { syntax }),
4134 _ => return None,
4135 };
4136 Some(res)
4137 }
4138 fn syntax(&self) -> &SyntaxNode {
4139 match self {
4140 TypeRef::ParenType(it) => &it.syntax,
4141 TypeRef::TupleType(it) => &it.syntax,
4142 TypeRef::NeverType(it) => &it.syntax,
4143 TypeRef::PathType(it) => &it.syntax,
4144 TypeRef::PointerType(it) => &it.syntax,
4145 TypeRef::ArrayType(it) => &it.syntax,
4146 TypeRef::SliceType(it) => &it.syntax,
4147 TypeRef::ReferenceType(it) => &it.syntax,
4148 TypeRef::PlaceholderType(it) => &it.syntax,
4149 TypeRef::FnPointerType(it) => &it.syntax,
4150 TypeRef::ForType(it) => &it.syntax,
4151 TypeRef::ImplTraitType(it) => &it.syntax,
4152 TypeRef::DynTraitType(it) => &it.syntax,
4153 }
4154 }
4155}
4156#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4157pub enum ModuleItem {
4158 StructDef(StructDef),
4159 UnionDef(UnionDef),
4160 EnumDef(EnumDef),
4161 FnDef(FnDef),
4162 TraitDef(TraitDef),
4163 TypeAliasDef(TypeAliasDef),
4164 ImplDef(ImplDef),
4165 UseItem(UseItem),
4166 ExternCrateItem(ExternCrateItem),
4167 ConstDef(ConstDef),
4168 StaticDef(StaticDef),
4169 Module(Module),
4170 MacroCall(MacroCall),
4171}
4172impl From<StructDef> for ModuleItem {
4173 fn from(node: StructDef) -> ModuleItem {
4174 ModuleItem::StructDef(node)
4175 }
4176}
4177impl From<UnionDef> for ModuleItem {
4178 fn from(node: UnionDef) -> ModuleItem {
4179 ModuleItem::UnionDef(node)
4180 }
4181}
4182impl From<EnumDef> for ModuleItem {
4183 fn from(node: EnumDef) -> ModuleItem {
4184 ModuleItem::EnumDef(node)
4185 }
4186}
4187impl From<FnDef> for ModuleItem {
4188 fn from(node: FnDef) -> ModuleItem {
4189 ModuleItem::FnDef(node)
4190 }
4191}
4192impl From<TraitDef> for ModuleItem {
4193 fn from(node: TraitDef) -> ModuleItem {
4194 ModuleItem::TraitDef(node)
4195 }
4196}
4197impl From<TypeAliasDef> for ModuleItem {
4198 fn from(node: TypeAliasDef) -> ModuleItem {
4199 ModuleItem::TypeAliasDef(node)
4200 }
4201}
4202impl From<ImplDef> for ModuleItem {
4203 fn from(node: ImplDef) -> ModuleItem {
4204 ModuleItem::ImplDef(node)
4205 }
4206}
4207impl From<UseItem> for ModuleItem {
4208 fn from(node: UseItem) -> ModuleItem {
4209 ModuleItem::UseItem(node)
4210 }
4211}
4212impl From<ExternCrateItem> for ModuleItem {
4213 fn from(node: ExternCrateItem) -> ModuleItem {
4214 ModuleItem::ExternCrateItem(node)
4215 }
4216}
4217impl From<ConstDef> for ModuleItem {
4218 fn from(node: ConstDef) -> ModuleItem {
4219 ModuleItem::ConstDef(node)
4220 }
4221}
4222impl From<StaticDef> for ModuleItem {
4223 fn from(node: StaticDef) -> ModuleItem {
4224 ModuleItem::StaticDef(node)
4225 }
4226}
4227impl From<Module> for ModuleItem {
4228 fn from(node: Module) -> ModuleItem {
4229 ModuleItem::Module(node)
4230 }
4231}
4232impl From<MacroCall> for ModuleItem {
4233 fn from(node: MacroCall) -> ModuleItem {
4234 ModuleItem::MacroCall(node)
4235 }
4236}
4237impl std::fmt::Display for ModuleItem {
4238 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4239 std::fmt::Display::fmt(self.syntax(), f)
4240 }
4241}
4242impl AstNode for ModuleItem {
4243 fn can_cast(kind: SyntaxKind) -> bool {
4244 match kind {
4245 STRUCT_DEF | UNION_DEF | ENUM_DEF | FN_DEF | TRAIT_DEF | TYPE_ALIAS_DEF | IMPL_DEF
4246 | USE_ITEM | EXTERN_CRATE_ITEM | CONST_DEF | STATIC_DEF | MODULE | MACRO_CALL => true,
4247 _ => false,
4248 }
4249 }
4250 fn cast(syntax: SyntaxNode) -> Option<Self> {
4251 let res = match syntax.kind() {
4252 STRUCT_DEF => ModuleItem::StructDef(StructDef { syntax }),
4253 UNION_DEF => ModuleItem::UnionDef(UnionDef { syntax }),
4254 ENUM_DEF => ModuleItem::EnumDef(EnumDef { syntax }),
4255 FN_DEF => ModuleItem::FnDef(FnDef { syntax }),
4256 TRAIT_DEF => ModuleItem::TraitDef(TraitDef { syntax }),
4257 TYPE_ALIAS_DEF => ModuleItem::TypeAliasDef(TypeAliasDef { syntax }),
4258 IMPL_DEF => ModuleItem::ImplDef(ImplDef { syntax }),
4259 USE_ITEM => ModuleItem::UseItem(UseItem { syntax }),
4260 EXTERN_CRATE_ITEM => ModuleItem::ExternCrateItem(ExternCrateItem { syntax }),
4261 CONST_DEF => ModuleItem::ConstDef(ConstDef { syntax }),
4262 STATIC_DEF => ModuleItem::StaticDef(StaticDef { syntax }),
4263 MODULE => ModuleItem::Module(Module { syntax }),
4264 MACRO_CALL => ModuleItem::MacroCall(MacroCall { syntax }),
4265 _ => return None,
4266 };
4267 Some(res)
4268 }
4269 fn syntax(&self) -> &SyntaxNode {
4270 match self {
4271 ModuleItem::StructDef(it) => &it.syntax,
4272 ModuleItem::UnionDef(it) => &it.syntax,
4273 ModuleItem::EnumDef(it) => &it.syntax,
4274 ModuleItem::FnDef(it) => &it.syntax,
4275 ModuleItem::TraitDef(it) => &it.syntax,
4276 ModuleItem::TypeAliasDef(it) => &it.syntax,
4277 ModuleItem::ImplDef(it) => &it.syntax,
4278 ModuleItem::UseItem(it) => &it.syntax,
4279 ModuleItem::ExternCrateItem(it) => &it.syntax,
4280 ModuleItem::ConstDef(it) => &it.syntax,
4281 ModuleItem::StaticDef(it) => &it.syntax,
4282 ModuleItem::Module(it) => &it.syntax,
4283 ModuleItem::MacroCall(it) => &it.syntax,
4284 }
4285 }
4286}
4287impl ast::AttrsOwner for ModuleItem {}
4288impl ast::VisibilityOwner for ModuleItem {}
4289#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4290pub enum ImplItem {
4291 FnDef(FnDef),
4292 TypeAliasDef(TypeAliasDef),
4293 ConstDef(ConstDef),
4294}
4295impl From<FnDef> for ImplItem {
4296 fn from(node: FnDef) -> ImplItem {
4297 ImplItem::FnDef(node)
4298 }
4299}
4300impl From<TypeAliasDef> for ImplItem {
4301 fn from(node: TypeAliasDef) -> ImplItem {
4302 ImplItem::TypeAliasDef(node)
4303 }
4304}
4305impl From<ConstDef> for ImplItem {
4306 fn from(node: ConstDef) -> ImplItem {
4307 ImplItem::ConstDef(node)
4308 }
4309}
4310impl std::fmt::Display for ImplItem {
4311 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4312 std::fmt::Display::fmt(self.syntax(), f)
4313 }
4314}
4315impl AstNode for ImplItem {
4316 fn can_cast(kind: SyntaxKind) -> bool {
4317 match kind {
4318 FN_DEF | TYPE_ALIAS_DEF | CONST_DEF => true,
4319 _ => false,
4320 }
4321 }
4322 fn cast(syntax: SyntaxNode) -> Option<Self> {
4323 let res = match syntax.kind() {
4324 FN_DEF => ImplItem::FnDef(FnDef { syntax }),
4325 TYPE_ALIAS_DEF => ImplItem::TypeAliasDef(TypeAliasDef { syntax }),
4326 CONST_DEF => ImplItem::ConstDef(ConstDef { syntax }),
4327 _ => return None,
4328 };
4329 Some(res)
4330 }
4331 fn syntax(&self) -> &SyntaxNode {
4332 match self {
4333 ImplItem::FnDef(it) => &it.syntax,
4334 ImplItem::TypeAliasDef(it) => &it.syntax,
4335 ImplItem::ConstDef(it) => &it.syntax,
4336 }
4337 }
4338}
4339impl ast::AttrsOwner for ImplItem {}
4340#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4341pub enum Expr {
4342 TupleExpr(TupleExpr),
4343 ArrayExpr(ArrayExpr),
4344 ParenExpr(ParenExpr),
4345 PathExpr(PathExpr),
4346 LambdaExpr(LambdaExpr),
4347 IfExpr(IfExpr),
4348 LoopExpr(LoopExpr),
4349 ForExpr(ForExpr),
4350 WhileExpr(WhileExpr),
4351 ContinueExpr(ContinueExpr),
4352 BreakExpr(BreakExpr),
4353 Label(Label),
4354 BlockExpr(BlockExpr),
4355 ReturnExpr(ReturnExpr),
4356 MatchExpr(MatchExpr),
4357 RecordLit(RecordLit),
4358 CallExpr(CallExpr),
4359 IndexExpr(IndexExpr),
4360 MethodCallExpr(MethodCallExpr),
4361 FieldExpr(FieldExpr),
4362 AwaitExpr(AwaitExpr),
4363 TryExpr(TryExpr),
4364 TryBlockExpr(TryBlockExpr),
4365 CastExpr(CastExpr),
4366 RefExpr(RefExpr),
4367 PrefixExpr(PrefixExpr),
4368 RangeExpr(RangeExpr),
4369 BinExpr(BinExpr),
4370 Literal(Literal),
4371 MacroCall(MacroCall),
4372 BoxExpr(BoxExpr),
4373}
4374impl From<TupleExpr> for Expr {
4375 fn from(node: TupleExpr) -> Expr {
4376 Expr::TupleExpr(node)
4377 }
4378}
4379impl From<ArrayExpr> for Expr {
4380 fn from(node: ArrayExpr) -> Expr {
4381 Expr::ArrayExpr(node)
4382 }
4383}
4384impl From<ParenExpr> for Expr {
4385 fn from(node: ParenExpr) -> Expr {
4386 Expr::ParenExpr(node)
4387 }
4388}
4389impl From<PathExpr> for Expr {
4390 fn from(node: PathExpr) -> Expr {
4391 Expr::PathExpr(node)
4392 }
4393}
4394impl From<LambdaExpr> for Expr {
4395 fn from(node: LambdaExpr) -> Expr {
4396 Expr::LambdaExpr(node)
4397 }
4398}
4399impl From<IfExpr> for Expr {
4400 fn from(node: IfExpr) -> Expr {
4401 Expr::IfExpr(node)
4402 }
4403}
4404impl From<LoopExpr> for Expr {
4405 fn from(node: LoopExpr) -> Expr {
4406 Expr::LoopExpr(node)
4407 }
4408}
4409impl From<ForExpr> for Expr {
4410 fn from(node: ForExpr) -> Expr {
4411 Expr::ForExpr(node)
4412 }
4413}
4414impl From<WhileExpr> for Expr {
4415 fn from(node: WhileExpr) -> Expr {
4416 Expr::WhileExpr(node)
4417 }
4418}
4419impl From<ContinueExpr> for Expr {
4420 fn from(node: ContinueExpr) -> Expr {
4421 Expr::ContinueExpr(node)
4422 }
4423}
4424impl From<BreakExpr> for Expr {
4425 fn from(node: BreakExpr) -> Expr {
4426 Expr::BreakExpr(node)
4427 }
4428}
4429impl From<Label> for Expr {
4430 fn from(node: Label) -> Expr {
4431 Expr::Label(node)
4432 }
4433}
4434impl From<BlockExpr> for Expr {
4435 fn from(node: BlockExpr) -> Expr {
4436 Expr::BlockExpr(node)
4437 }
4438}
4439impl From<ReturnExpr> for Expr {
4440 fn from(node: ReturnExpr) -> Expr {
4441 Expr::ReturnExpr(node)
4442 }
4443}
4444impl From<MatchExpr> for Expr {
4445 fn from(node: MatchExpr) -> Expr {
4446 Expr::MatchExpr(node)
4447 }
4448}
4449impl From<RecordLit> for Expr {
4450 fn from(node: RecordLit) -> Expr {
4451 Expr::RecordLit(node)
4452 }
4453}
4454impl From<CallExpr> for Expr {
4455 fn from(node: CallExpr) -> Expr {
4456 Expr::CallExpr(node)
4457 }
4458}
4459impl From<IndexExpr> for Expr {
4460 fn from(node: IndexExpr) -> Expr {
4461 Expr::IndexExpr(node)
4462 }
4463}
4464impl From<MethodCallExpr> for Expr {
4465 fn from(node: MethodCallExpr) -> Expr {
4466 Expr::MethodCallExpr(node)
4467 }
4468}
4469impl From<FieldExpr> for Expr {
4470 fn from(node: FieldExpr) -> Expr {
4471 Expr::FieldExpr(node)
4472 }
4473}
4474impl From<AwaitExpr> for Expr {
4475 fn from(node: AwaitExpr) -> Expr {
4476 Expr::AwaitExpr(node)
4477 }
4478}
4479impl From<TryExpr> for Expr {
4480 fn from(node: TryExpr) -> Expr {
4481 Expr::TryExpr(node)
4482 }
4483}
4484impl From<TryBlockExpr> for Expr {
4485 fn from(node: TryBlockExpr) -> Expr {
4486 Expr::TryBlockExpr(node)
4487 }
4488}
4489impl From<CastExpr> for Expr {
4490 fn from(node: CastExpr) -> Expr {
4491 Expr::CastExpr(node)
4492 }
4493}
4494impl From<RefExpr> for Expr {
4495 fn from(node: RefExpr) -> Expr {
4496 Expr::RefExpr(node)
4497 }
4498}
4499impl From<PrefixExpr> for Expr {
4500 fn from(node: PrefixExpr) -> Expr {
4501 Expr::PrefixExpr(node)
4502 }
4503}
4504impl From<RangeExpr> for Expr {
4505 fn from(node: RangeExpr) -> Expr {
4506 Expr::RangeExpr(node)
4507 }
4508}
4509impl From<BinExpr> for Expr {
4510 fn from(node: BinExpr) -> Expr {
4511 Expr::BinExpr(node)
4512 }
4513}
4514impl From<Literal> for Expr {
4515 fn from(node: Literal) -> Expr {
4516 Expr::Literal(node)
4517 }
4518}
4519impl From<MacroCall> for Expr {
4520 fn from(node: MacroCall) -> Expr {
4521 Expr::MacroCall(node)
4522 }
4523}
4524impl From<BoxExpr> for Expr {
4525 fn from(node: BoxExpr) -> Expr {
4526 Expr::BoxExpr(node)
4527 }
4528}
4529impl std::fmt::Display for Expr {
4530 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4531 std::fmt::Display::fmt(self.syntax(), f)
4532 }
4533}
4534impl AstNode for Expr {
4535 fn can_cast(kind: SyntaxKind) -> bool {
4536 match kind {
4537 TUPLE_EXPR | ARRAY_EXPR | PAREN_EXPR | PATH_EXPR | LAMBDA_EXPR | IF_EXPR
4538 | LOOP_EXPR | FOR_EXPR | WHILE_EXPR | CONTINUE_EXPR | BREAK_EXPR | LABEL
4539 | BLOCK_EXPR | RETURN_EXPR | MATCH_EXPR | RECORD_LIT | CALL_EXPR | INDEX_EXPR
4540 | METHOD_CALL_EXPR | FIELD_EXPR | AWAIT_EXPR | TRY_EXPR | TRY_BLOCK_EXPR
4541 | CAST_EXPR | REF_EXPR | PREFIX_EXPR | RANGE_EXPR | BIN_EXPR | LITERAL | MACRO_CALL
4542 | BOX_EXPR => true,
4543 _ => false,
4544 }
4545 }
4546 fn cast(syntax: SyntaxNode) -> Option<Self> {
4547 let res = match syntax.kind() {
4548 TUPLE_EXPR => Expr::TupleExpr(TupleExpr { syntax }),
4549 ARRAY_EXPR => Expr::ArrayExpr(ArrayExpr { syntax }),
4550 PAREN_EXPR => Expr::ParenExpr(ParenExpr { syntax }),
4551 PATH_EXPR => Expr::PathExpr(PathExpr { syntax }),
4552 LAMBDA_EXPR => Expr::LambdaExpr(LambdaExpr { syntax }),
4553 IF_EXPR => Expr::IfExpr(IfExpr { syntax }),
4554 LOOP_EXPR => Expr::LoopExpr(LoopExpr { syntax }),
4555 FOR_EXPR => Expr::ForExpr(ForExpr { syntax }),
4556 WHILE_EXPR => Expr::WhileExpr(WhileExpr { syntax }),
4557 CONTINUE_EXPR => Expr::ContinueExpr(ContinueExpr { syntax }),
4558 BREAK_EXPR => Expr::BreakExpr(BreakExpr { syntax }),
4559 LABEL => Expr::Label(Label { syntax }),
4560 BLOCK_EXPR => Expr::BlockExpr(BlockExpr { syntax }),
4561 RETURN_EXPR => Expr::ReturnExpr(ReturnExpr { syntax }),
4562 MATCH_EXPR => Expr::MatchExpr(MatchExpr { syntax }),
4563 RECORD_LIT => Expr::RecordLit(RecordLit { syntax }),
4564 CALL_EXPR => Expr::CallExpr(CallExpr { syntax }),
4565 INDEX_EXPR => Expr::IndexExpr(IndexExpr { syntax }),
4566 METHOD_CALL_EXPR => Expr::MethodCallExpr(MethodCallExpr { syntax }),
4567 FIELD_EXPR => Expr::FieldExpr(FieldExpr { syntax }),
4568 AWAIT_EXPR => Expr::AwaitExpr(AwaitExpr { syntax }),
4569 TRY_EXPR => Expr::TryExpr(TryExpr { syntax }),
4570 TRY_BLOCK_EXPR => Expr::TryBlockExpr(TryBlockExpr { syntax }),
4571 CAST_EXPR => Expr::CastExpr(CastExpr { syntax }),
4572 REF_EXPR => Expr::RefExpr(RefExpr { syntax }),
4573 PREFIX_EXPR => Expr::PrefixExpr(PrefixExpr { syntax }),
4574 RANGE_EXPR => Expr::RangeExpr(RangeExpr { syntax }),
4575 BIN_EXPR => Expr::BinExpr(BinExpr { syntax }),
4576 LITERAL => Expr::Literal(Literal { syntax }),
4577 MACRO_CALL => Expr::MacroCall(MacroCall { syntax }),
4578 BOX_EXPR => Expr::BoxExpr(BoxExpr { syntax }),
4579 _ => return None,
4580 };
4581 Some(res)
4582 }
4583 fn syntax(&self) -> &SyntaxNode {
4584 match self {
4585 Expr::TupleExpr(it) => &it.syntax,
4586 Expr::ArrayExpr(it) => &it.syntax,
4587 Expr::ParenExpr(it) => &it.syntax,
4588 Expr::PathExpr(it) => &it.syntax,
4589 Expr::LambdaExpr(it) => &it.syntax,
4590 Expr::IfExpr(it) => &it.syntax,
4591 Expr::LoopExpr(it) => &it.syntax,
4592 Expr::ForExpr(it) => &it.syntax,
4593 Expr::WhileExpr(it) => &it.syntax,
4594 Expr::ContinueExpr(it) => &it.syntax,
4595 Expr::BreakExpr(it) => &it.syntax,
4596 Expr::Label(it) => &it.syntax,
4597 Expr::BlockExpr(it) => &it.syntax,
4598 Expr::ReturnExpr(it) => &it.syntax,
4599 Expr::MatchExpr(it) => &it.syntax,
4600 Expr::RecordLit(it) => &it.syntax,
4601 Expr::CallExpr(it) => &it.syntax,
4602 Expr::IndexExpr(it) => &it.syntax,
4603 Expr::MethodCallExpr(it) => &it.syntax,
4604 Expr::FieldExpr(it) => &it.syntax,
4605 Expr::AwaitExpr(it) => &it.syntax,
4606 Expr::TryExpr(it) => &it.syntax,
4607 Expr::TryBlockExpr(it) => &it.syntax,
4608 Expr::CastExpr(it) => &it.syntax,
4609 Expr::RefExpr(it) => &it.syntax,
4610 Expr::PrefixExpr(it) => &it.syntax,
4611 Expr::RangeExpr(it) => &it.syntax,
4612 Expr::BinExpr(it) => &it.syntax,
4613 Expr::Literal(it) => &it.syntax,
4614 Expr::MacroCall(it) => &it.syntax,
4615 Expr::BoxExpr(it) => &it.syntax,
4616 }
4617 }
4618}
4619#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4620pub enum Pat {
4621 OrPat(OrPat),
4622 ParenPat(ParenPat),
4623 RefPat(RefPat),
4624 BoxPat(BoxPat),
4625 BindPat(BindPat),
4626 PlaceholderPat(PlaceholderPat),
4627 DotDotPat(DotDotPat),
4628 PathPat(PathPat),
4629 RecordPat(RecordPat),
4630 TupleStructPat(TupleStructPat),
4631 TuplePat(TuplePat),
4632 SlicePat(SlicePat),
4633 RangePat(RangePat),
4634 LiteralPat(LiteralPat),
4635 MacroPat(MacroPat),
4636}
4637impl From<OrPat> for Pat {
4638 fn from(node: OrPat) -> Pat {
4639 Pat::OrPat(node)
4640 }
4641}
4642impl From<ParenPat> for Pat {
4643 fn from(node: ParenPat) -> Pat {
4644 Pat::ParenPat(node)
4645 }
4646}
4647impl From<RefPat> for Pat {
4648 fn from(node: RefPat) -> Pat {
4649 Pat::RefPat(node)
4650 }
4651}
4652impl From<BoxPat> for Pat {
4653 fn from(node: BoxPat) -> Pat {
4654 Pat::BoxPat(node)
4655 }
4656}
4657impl From<BindPat> for Pat {
4658 fn from(node: BindPat) -> Pat {
4659 Pat::BindPat(node)
4660 }
4661}
4662impl From<PlaceholderPat> for Pat {
4663 fn from(node: PlaceholderPat) -> Pat {
4664 Pat::PlaceholderPat(node)
4665 }
4666}
4667impl From<DotDotPat> for Pat {
4668 fn from(node: DotDotPat) -> Pat {
4669 Pat::DotDotPat(node)
4670 }
4671}
4672impl From<PathPat> for Pat {
4673 fn from(node: PathPat) -> Pat {
4674 Pat::PathPat(node)
4675 }
4676}
4677impl From<RecordPat> for Pat {
4678 fn from(node: RecordPat) -> Pat {
4679 Pat::RecordPat(node)
4680 }
4681}
4682impl From<TupleStructPat> for Pat {
4683 fn from(node: TupleStructPat) -> Pat {
4684 Pat::TupleStructPat(node)
4685 }
4686}
4687impl From<TuplePat> for Pat {
4688 fn from(node: TuplePat) -> Pat {
4689 Pat::TuplePat(node)
4690 }
4691}
4692impl From<SlicePat> for Pat {
4693 fn from(node: SlicePat) -> Pat {
4694 Pat::SlicePat(node)
4695 }
4696}
4697impl From<RangePat> for Pat {
4698 fn from(node: RangePat) -> Pat {
4699 Pat::RangePat(node)
4700 }
4701}
4702impl From<LiteralPat> for Pat {
4703 fn from(node: LiteralPat) -> Pat {
4704 Pat::LiteralPat(node)
4705 }
4706}
4707impl From<MacroPat> for Pat {
4708 fn from(node: MacroPat) -> Pat {
4709 Pat::MacroPat(node)
4710 }
4711}
4712impl std::fmt::Display for Pat {
4713 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4714 std::fmt::Display::fmt(self.syntax(), f)
4715 }
4716}
4717impl AstNode for Pat {
4718 fn can_cast(kind: SyntaxKind) -> bool {
4719 match kind {
4720 OR_PAT | PAREN_PAT | REF_PAT | BOX_PAT | BIND_PAT | PLACEHOLDER_PAT | DOT_DOT_PAT
4721 | PATH_PAT | RECORD_PAT | TUPLE_STRUCT_PAT | TUPLE_PAT | SLICE_PAT | RANGE_PAT
4722 | LITERAL_PAT | MACRO_PAT => true,
4723 _ => false,
4724 }
4725 }
4726 fn cast(syntax: SyntaxNode) -> Option<Self> {
4727 let res = match syntax.kind() {
4728 OR_PAT => Pat::OrPat(OrPat { syntax }),
4729 PAREN_PAT => Pat::ParenPat(ParenPat { syntax }),
4730 REF_PAT => Pat::RefPat(RefPat { syntax }),
4731 BOX_PAT => Pat::BoxPat(BoxPat { syntax }),
4732 BIND_PAT => Pat::BindPat(BindPat { syntax }),
4733 PLACEHOLDER_PAT => Pat::PlaceholderPat(PlaceholderPat { syntax }),
4734 DOT_DOT_PAT => Pat::DotDotPat(DotDotPat { syntax }),
4735 PATH_PAT => Pat::PathPat(PathPat { syntax }),
4736 RECORD_PAT => Pat::RecordPat(RecordPat { syntax }),
4737 TUPLE_STRUCT_PAT => Pat::TupleStructPat(TupleStructPat { syntax }),
4738 TUPLE_PAT => Pat::TuplePat(TuplePat { syntax }),
4739 SLICE_PAT => Pat::SlicePat(SlicePat { syntax }),
4740 RANGE_PAT => Pat::RangePat(RangePat { syntax }),
4741 LITERAL_PAT => Pat::LiteralPat(LiteralPat { syntax }),
4742 MACRO_PAT => Pat::MacroPat(MacroPat { syntax }),
4743 _ => return None,
4744 };
4745 Some(res)
4746 }
4747 fn syntax(&self) -> &SyntaxNode {
4748 match self {
4749 Pat::OrPat(it) => &it.syntax,
4750 Pat::ParenPat(it) => &it.syntax,
4751 Pat::RefPat(it) => &it.syntax,
4752 Pat::BoxPat(it) => &it.syntax,
4753 Pat::BindPat(it) => &it.syntax,
4754 Pat::PlaceholderPat(it) => &it.syntax,
4755 Pat::DotDotPat(it) => &it.syntax,
4756 Pat::PathPat(it) => &it.syntax,
4757 Pat::RecordPat(it) => &it.syntax,
4758 Pat::TupleStructPat(it) => &it.syntax,
4759 Pat::TuplePat(it) => &it.syntax,
4760 Pat::SlicePat(it) => &it.syntax,
4761 Pat::RangePat(it) => &it.syntax,
4762 Pat::LiteralPat(it) => &it.syntax,
4763 Pat::MacroPat(it) => &it.syntax,
4764 }
4765 }
4766}
4767#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4768pub enum AttrInput {
4769 Literal(Literal),
4770 TokenTree(TokenTree),
4771}
4772impl From<Literal> for AttrInput {
4773 fn from(node: Literal) -> AttrInput {
4774 AttrInput::Literal(node)
4775 }
4776}
4777impl From<TokenTree> for AttrInput {
4778 fn from(node: TokenTree) -> AttrInput {
4779 AttrInput::TokenTree(node)
4780 }
4781}
4782impl std::fmt::Display for AttrInput {
4783 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4784 std::fmt::Display::fmt(self.syntax(), f)
4785 }
4786}
4787impl AstNode for AttrInput {
4788 fn can_cast(kind: SyntaxKind) -> bool {
4789 match kind {
4790 LITERAL | TOKEN_TREE => true,
4791 _ => false,
4792 }
4793 }
4794 fn cast(syntax: SyntaxNode) -> Option<Self> {
4795 let res = match syntax.kind() {
4796 LITERAL => AttrInput::Literal(Literal { syntax }),
4797 TOKEN_TREE => AttrInput::TokenTree(TokenTree { syntax }),
4798 _ => return None,
4799 };
4800 Some(res)
4801 }
4802 fn syntax(&self) -> &SyntaxNode {
4803 match self {
4804 AttrInput::Literal(it) => &it.syntax,
4805 AttrInput::TokenTree(it) => &it.syntax,
4806 }
4807 }
4808}
4809#[derive(Debug, Clone, PartialEq, Eq, Hash)]
4810pub enum Stmt {
4811 ExprStmt(ExprStmt),
4812 LetStmt(LetStmt),
4813}
4814impl From<ExprStmt> for Stmt {
4815 fn from(node: ExprStmt) -> Stmt {
4816 Stmt::ExprStmt(node)
4817 }
4818}
4819impl From<LetStmt> for Stmt {
4820 fn from(node: LetStmt) -> Stmt {
4821 Stmt::LetStmt(node)
4822 }
4823}
4824impl std::fmt::Display for Stmt {
4825 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
4826 std::fmt::Display::fmt(self.syntax(), f)
4827 }
4828}
4829impl AstNode for Stmt {
4830 fn can_cast(kind: SyntaxKind) -> bool {
4831 match kind {
4832 EXPR_STMT | LET_STMT => true,
4833 _ => false,
4834 }
4835 }
4836 fn cast(syntax: SyntaxNode) -> Option<Self> {
4837 let res = match syntax.kind() {
4838 EXPR_STMT => Stmt::ExprStmt(ExprStmt { syntax }),
4839 LET_STMT => Stmt::LetStmt(LetStmt { syntax }),
4840 _ => return None,
4841 };
4842 Some(res)
4843 }
4844 fn syntax(&self) -> &SyntaxNode {
4845 match self {
4846 Stmt::ExprStmt(it) => &it.syntax,
4847 Stmt::LetStmt(it) => &it.syntax,
4848 }
4849 }
4850}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-05 05:29:26 +0000