aboutsummaryrefslogtreecommitdiff
path: root/crates/ra_syntax/src/ast/generated
diff options
context:
space:
mode:
Diffstat (limited to 'crates/ra_syntax/src/ast/generated')
-rw-r--r--crates/ra_syntax/src/ast/generated/nodes.rs254
1 files changed, 127 insertions, 127 deletions
diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs
index 4306efe13..9cfd5d017 100644
--- a/crates/ra_syntax/src/ast/generated/nodes.rs
+++ b/crates/ra_syntax/src/ast/generated/nodes.rs
@@ -40,7 +40,7 @@ impl Const {
40 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } 40 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
41 pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) } 41 pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) }
42 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } 42 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
43 pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) } 43 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
44 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } 44 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
45 pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) } 45 pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
46 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } 46 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
@@ -112,7 +112,7 @@ impl Impl {
112 pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) } 112 pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) }
113 pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) } 113 pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) }
114 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } 114 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
115 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 115 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
116 pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) } 116 pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) }
117 pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) } 117 pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
118 pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) } 118 pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) }
@@ -152,7 +152,7 @@ impl Static {
152 pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) } 152 pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) }
153 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } 153 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
154 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } 154 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
155 pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) } 155 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
156 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } 156 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
157 pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) } 157 pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
158 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } 158 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
@@ -198,7 +198,7 @@ impl TypeAlias {
198 pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) } 198 pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) }
199 pub fn type_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![type]) } 199 pub fn type_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![type]) }
200 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } 200 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
201 pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) } 201 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
202 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } 202 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
203} 203}
204#[derive(Debug, Clone, PartialEq, Eq, Hash)] 204#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -333,7 +333,7 @@ pub struct RetType {
333} 333}
334impl RetType { 334impl RetType {
335 pub fn thin_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![->]) } 335 pub fn thin_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![->]) }
336 pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) } 336 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
337} 337}
338#[derive(Debug, Clone, PartialEq, Eq, Hash)] 338#[derive(Debug, Clone, PartialEq, Eq, Hash)]
339pub struct WhereClause { 339pub struct WhereClause {
@@ -369,7 +369,7 @@ impl SelfParam {
369 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } 369 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
370 pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) } 370 pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) }
371 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } 371 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
372 pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) } 372 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
373} 373}
374#[derive(Debug, Clone, PartialEq, Eq, Hash)] 374#[derive(Debug, Clone, PartialEq, Eq, Hash)]
375pub struct Param { 375pub struct Param {
@@ -379,7 +379,7 @@ impl ast::AttrsOwner for Param {}
379impl Param { 379impl Param {
380 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 380 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
381 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } 381 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
382 pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) } 382 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
383 pub fn dotdotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![...]) } 383 pub fn dotdotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![...]) }
384} 384}
385#[derive(Debug, Clone, PartialEq, Eq, Hash)] 385#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -416,7 +416,7 @@ impl ast::NameOwner for RecordField {}
416impl ast::VisibilityOwner for RecordField {} 416impl ast::VisibilityOwner for RecordField {}
417impl RecordField { 417impl RecordField {
418 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } 418 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
419 pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) } 419 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
420} 420}
421#[derive(Debug, Clone, PartialEq, Eq, Hash)] 421#[derive(Debug, Clone, PartialEq, Eq, Hash)]
422pub struct TupleField { 422pub struct TupleField {
@@ -425,7 +425,7 @@ pub struct TupleField {
425impl ast::AttrsOwner for TupleField {} 425impl ast::AttrsOwner for TupleField {}
426impl ast::VisibilityOwner for TupleField {} 426impl ast::VisibilityOwner for TupleField {}
427impl TupleField { 427impl TupleField {
428 pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) } 428 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
429} 429}
430#[derive(Debug, Clone, PartialEq, Eq, Hash)] 430#[derive(Debug, Clone, PartialEq, Eq, Hash)]
431pub struct VariantList { 431pub struct VariantList {
@@ -487,7 +487,7 @@ impl ast::NameOwner for TypeParam {}
487impl ast::TypeBoundsOwner for TypeParam {} 487impl ast::TypeBoundsOwner for TypeParam {}
488impl TypeParam { 488impl TypeParam {
489 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } 489 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
490 pub fn default_type(&self) -> Option<TypeRef> { support::child(&self.syntax) } 490 pub fn default_type(&self) -> Option<Type> { support::child(&self.syntax) }
491} 491}
492#[derive(Debug, Clone, PartialEq, Eq, Hash)] 492#[derive(Debug, Clone, PartialEq, Eq, Hash)]
493pub struct ConstParam { 493pub struct ConstParam {
@@ -498,7 +498,7 @@ impl ast::NameOwner for ConstParam {}
498impl ConstParam { 498impl ConstParam {
499 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } 499 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
500 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } 500 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
501 pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) } 501 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
502 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } 502 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
503 pub fn default_val(&self) -> Option<Expr> { support::child(&self.syntax) } 503 pub fn default_val(&self) -> Option<Expr> { support::child(&self.syntax) }
504} 504}
@@ -525,7 +525,7 @@ pub struct ParenType {
525} 525}
526impl ParenType { 526impl ParenType {
527 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } 527 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
528 pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) } 528 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
529 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } 529 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
530} 530}
531#[derive(Debug, Clone, PartialEq, Eq, Hash)] 531#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -534,7 +534,7 @@ pub struct TupleType {
534} 534}
535impl TupleType { 535impl TupleType {
536 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } 536 pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) }
537 pub fn fields(&self) -> AstChildren<TypeRef> { support::children(&self.syntax) } 537 pub fn fields(&self) -> AstChildren<Type> { support::children(&self.syntax) }
538 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } 538 pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) }
539} 539}
540#[derive(Debug, Clone, PartialEq, Eq, Hash)] 540#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -559,7 +559,7 @@ impl PointerType {
559 pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) } 559 pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) }
560 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } 560 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
561 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } 561 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
562 pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) } 562 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
563} 563}
564#[derive(Debug, Clone, PartialEq, Eq, Hash)] 564#[derive(Debug, Clone, PartialEq, Eq, Hash)]
565pub struct ArrayType { 565pub struct ArrayType {
@@ -567,7 +567,7 @@ pub struct ArrayType {
567} 567}
568impl ArrayType { 568impl ArrayType {
569 pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } 569 pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
570 pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) } 570 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
571 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } 571 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
572 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 572 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
573 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } 573 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
@@ -578,7 +578,7 @@ pub struct SliceType {
578} 578}
579impl SliceType { 579impl SliceType {
580 pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } 580 pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) }
581 pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) } 581 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
582 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } 582 pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) }
583} 583}
584#[derive(Debug, Clone, PartialEq, Eq, Hash)] 584#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -591,7 +591,7 @@ impl ReferenceType {
591 support::token(&self.syntax, T![lifetime]) 591 support::token(&self.syntax, T![lifetime])
592 } 592 }
593 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } 593 pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) }
594 pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) } 594 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
595} 595}
596#[derive(Debug, Clone, PartialEq, Eq, Hash)] 596#[derive(Debug, Clone, PartialEq, Eq, Hash)]
597pub struct PlaceholderType { 597pub struct PlaceholderType {
@@ -618,7 +618,7 @@ pub struct ForType {
618impl ForType { 618impl ForType {
619 pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) } 619 pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) }
620 pub fn generic_param_list(&self) -> Option<GenericParamList> { support::child(&self.syntax) } 620 pub fn generic_param_list(&self) -> Option<GenericParamList> { support::child(&self.syntax) }
621 pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) } 621 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
622} 622}
623#[derive(Debug, Clone, PartialEq, Eq, Hash)] 623#[derive(Debug, Clone, PartialEq, Eq, Hash)]
624pub struct ImplTraitType { 624pub struct ImplTraitType {
@@ -882,7 +882,7 @@ impl ast::AttrsOwner for CastExpr {}
882impl CastExpr { 882impl CastExpr {
883 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } 883 pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
884 pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) } 884 pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) }
885 pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) } 885 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
886} 886}
887#[derive(Debug, Clone, PartialEq, Eq, Hash)] 887#[derive(Debug, Clone, PartialEq, Eq, Hash)]
888pub struct RefExpr { 888pub struct RefExpr {
@@ -1174,7 +1174,7 @@ impl TypeBound {
1174 support::token(&self.syntax, T![lifetime]) 1174 support::token(&self.syntax, T![lifetime])
1175 } 1175 }
1176 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } 1176 pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) }
1177 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 1177 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1178} 1178}
1179#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1179#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1180pub struct WherePred { 1180pub struct WherePred {
@@ -1187,7 +1187,7 @@ impl WherePred {
1187 pub fn lifetime_token(&self) -> Option<SyntaxToken> { 1187 pub fn lifetime_token(&self) -> Option<SyntaxToken> {
1188 support::token(&self.syntax, T![lifetime]) 1188 support::token(&self.syntax, T![lifetime])
1189 } 1189 }
1190 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 1190 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1191} 1191}
1192#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1192#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1193pub struct ExprStmt { 1193pub struct ExprStmt {
@@ -1207,7 +1207,7 @@ impl LetStmt {
1207 pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) } 1207 pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) }
1208 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } 1208 pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
1209 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } 1209 pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) }
1210 pub fn ty(&self) -> Option<TypeRef> { support::child(&self.syntax) } 1210 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1211 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } 1211 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
1212 pub fn initializer(&self) -> Option<Expr> { support::child(&self.syntax) } 1212 pub fn initializer(&self) -> Option<Expr> { support::child(&self.syntax) }
1213 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } 1213 pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) }
@@ -1234,7 +1234,7 @@ pub struct TypeArg {
1234 pub(crate) syntax: SyntaxNode, 1234 pub(crate) syntax: SyntaxNode,
1235} 1235}
1236impl TypeArg { 1236impl TypeArg {
1237 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 1237 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1238} 1238}
1239#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1239#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1240pub struct LifetimeArg { 1240pub struct LifetimeArg {
@@ -1253,7 +1253,7 @@ impl ast::TypeBoundsOwner for AssocTypeArg {}
1253impl AssocTypeArg { 1253impl AssocTypeArg {
1254 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } 1254 pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
1255 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } 1255 pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
1256 pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } 1256 pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) }
1257} 1257}
1258#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1258#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1259pub struct ConstArg { 1259pub struct ConstArg {
@@ -1282,7 +1282,7 @@ pub enum Item {
1282} 1282}
1283impl ast::AttrsOwner for Item {} 1283impl ast::AttrsOwner for Item {}
1284#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1284#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1285pub enum TypeRef { 1285pub enum Type {
1286 ParenType(ParenType), 1286 ParenType(ParenType),
1287 TupleType(TupleType), 1287 TupleType(TupleType),
1288 NeverType(NeverType), 1288 NeverType(NeverType),
@@ -1355,6 +1355,16 @@ pub enum Expr {
1355 BoxExpr(BoxExpr), 1355 BoxExpr(BoxExpr),
1356} 1356}
1357#[derive(Debug, Clone, PartialEq, Eq, Hash)] 1357#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1358pub enum AdtDef {
1359 Struct(Struct),
1360 Enum(Enum),
1361 Union(Union),
1362}
1363impl ast::AttrsOwner for AdtDef {}
1364impl ast::GenericParamsOwner for AdtDef {}
1365impl ast::NameOwner for AdtDef {}
1366impl ast::VisibilityOwner for AdtDef {}
1367#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1358pub enum AssocItem { 1368pub enum AssocItem {
1359 Fn(Fn), 1369 Fn(Fn),
1360 TypeAlias(TypeAlias), 1370 TypeAlias(TypeAlias),
@@ -1384,16 +1394,6 @@ pub enum Stmt {
1384 ExprStmt(ExprStmt), 1394 ExprStmt(ExprStmt),
1385} 1395}
1386impl ast::AttrsOwner for Stmt {} 1396impl ast::AttrsOwner for Stmt {}
1387#[derive(Debug, Clone, PartialEq, Eq, Hash)]
1388pub enum AdtDef {
1389 Struct(Struct),
1390 Enum(Enum),
1391 Union(Union),
1392}
1393impl ast::AttrsOwner for AdtDef {}
1394impl ast::GenericParamsOwner for AdtDef {}
1395impl ast::NameOwner for AdtDef {}
1396impl ast::VisibilityOwner for AdtDef {}
1397impl AstNode for SourceFile { 1397impl AstNode for SourceFile {
1398 fn can_cast(kind: SyntaxKind) -> bool { kind == SOURCE_FILE } 1398 fn can_cast(kind: SyntaxKind) -> bool { kind == SOURCE_FILE }
1399 fn cast(syntax: SyntaxNode) -> Option<Self> { 1399 fn cast(syntax: SyntaxNode) -> Option<Self> {
@@ -2847,46 +2847,46 @@ impl AstNode for Item {
2847 } 2847 }
2848 } 2848 }
2849} 2849}
2850impl From<ParenType> for TypeRef { 2850impl From<ParenType> for Type {
2851 fn from(node: ParenType) -> TypeRef { TypeRef::ParenType(node) } 2851 fn from(node: ParenType) -> Type { Type::ParenType(node) }
2852} 2852}
2853impl From<TupleType> for TypeRef { 2853impl From<TupleType> for Type {
2854 fn from(node: TupleType) -> TypeRef { TypeRef::TupleType(node) } 2854 fn from(node: TupleType) -> Type { Type::TupleType(node) }
2855} 2855}
2856impl From<NeverType> for TypeRef { 2856impl From<NeverType> for Type {
2857 fn from(node: NeverType) -> TypeRef { TypeRef::NeverType(node) } 2857 fn from(node: NeverType) -> Type { Type::NeverType(node) }
2858} 2858}
2859impl From<PathType> for TypeRef { 2859impl From<PathType> for Type {
2860 fn from(node: PathType) -> TypeRef { TypeRef::PathType(node) } 2860 fn from(node: PathType) -> Type { Type::PathType(node) }
2861} 2861}
2862impl From<PointerType> for TypeRef { 2862impl From<PointerType> for Type {
2863 fn from(node: PointerType) -> TypeRef { TypeRef::PointerType(node) } 2863 fn from(node: PointerType) -> Type { Type::PointerType(node) }
2864} 2864}
2865impl From<ArrayType> for TypeRef { 2865impl From<ArrayType> for Type {
2866 fn from(node: ArrayType) -> TypeRef { TypeRef::ArrayType(node) } 2866 fn from(node: ArrayType) -> Type { Type::ArrayType(node) }
2867} 2867}
2868impl From<SliceType> for TypeRef { 2868impl From<SliceType> for Type {
2869 fn from(node: SliceType) -> TypeRef { TypeRef::SliceType(node) } 2869 fn from(node: SliceType) -> Type { Type::SliceType(node) }
2870} 2870}
2871impl From<ReferenceType> for TypeRef { 2871impl From<ReferenceType> for Type {
2872 fn from(node: ReferenceType) -> TypeRef { TypeRef::ReferenceType(node) } 2872 fn from(node: ReferenceType) -> Type { Type::ReferenceType(node) }
2873} 2873}
2874impl From<PlaceholderType> for TypeRef { 2874impl From<PlaceholderType> for Type {
2875 fn from(node: PlaceholderType) -> TypeRef { TypeRef::PlaceholderType(node) } 2875 fn from(node: PlaceholderType) -> Type { Type::PlaceholderType(node) }
2876} 2876}
2877impl From<FnPointerType> for TypeRef { 2877impl From<FnPointerType> for Type {
2878 fn from(node: FnPointerType) -> TypeRef { TypeRef::FnPointerType(node) } 2878 fn from(node: FnPointerType) -> Type { Type::FnPointerType(node) }
2879} 2879}
2880impl From<ForType> for TypeRef { 2880impl From<ForType> for Type {
2881 fn from(node: ForType) -> TypeRef { TypeRef::ForType(node) } 2881 fn from(node: ForType) -> Type { Type::ForType(node) }
2882} 2882}
2883impl From<ImplTraitType> for TypeRef { 2883impl From<ImplTraitType> for Type {
2884 fn from(node: ImplTraitType) -> TypeRef { TypeRef::ImplTraitType(node) } 2884 fn from(node: ImplTraitType) -> Type { Type::ImplTraitType(node) }
2885} 2885}
2886impl From<DynTraitType> for TypeRef { 2886impl From<DynTraitType> for Type {
2887 fn from(node: DynTraitType) -> TypeRef { TypeRef::DynTraitType(node) } 2887 fn from(node: DynTraitType) -> Type { Type::DynTraitType(node) }
2888} 2888}
2889impl AstNode for TypeRef { 2889impl AstNode for Type {
2890 fn can_cast(kind: SyntaxKind) -> bool { 2890 fn can_cast(kind: SyntaxKind) -> bool {
2891 match kind { 2891 match kind {
2892 PAREN_TYPE | TUPLE_TYPE | NEVER_TYPE | PATH_TYPE | POINTER_TYPE | ARRAY_TYPE 2892 PAREN_TYPE | TUPLE_TYPE | NEVER_TYPE | PATH_TYPE | POINTER_TYPE | ARRAY_TYPE
@@ -2897,38 +2897,38 @@ impl AstNode for TypeRef {
2897 } 2897 }
2898 fn cast(syntax: SyntaxNode) -> Option<Self> { 2898 fn cast(syntax: SyntaxNode) -> Option<Self> {
2899 let res = match syntax.kind() { 2899 let res = match syntax.kind() {
2900 PAREN_TYPE => TypeRef::ParenType(ParenType { syntax }), 2900 PAREN_TYPE => Type::ParenType(ParenType { syntax }),
2901 TUPLE_TYPE => TypeRef::TupleType(TupleType { syntax }), 2901 TUPLE_TYPE => Type::TupleType(TupleType { syntax }),
2902 NEVER_TYPE => TypeRef::NeverType(NeverType { syntax }), 2902 NEVER_TYPE => Type::NeverType(NeverType { syntax }),
2903 PATH_TYPE => TypeRef::PathType(PathType { syntax }), 2903 PATH_TYPE => Type::PathType(PathType { syntax }),
2904 POINTER_TYPE => TypeRef::PointerType(PointerType { syntax }), 2904 POINTER_TYPE => Type::PointerType(PointerType { syntax }),
2905 ARRAY_TYPE => TypeRef::ArrayType(ArrayType { syntax }), 2905 ARRAY_TYPE => Type::ArrayType(ArrayType { syntax }),
2906 SLICE_TYPE => TypeRef::SliceType(SliceType { syntax }), 2906 SLICE_TYPE => Type::SliceType(SliceType { syntax }),
2907 REFERENCE_TYPE => TypeRef::ReferenceType(ReferenceType { syntax }), 2907 REFERENCE_TYPE => Type::ReferenceType(ReferenceType { syntax }),
2908 PLACEHOLDER_TYPE => TypeRef::PlaceholderType(PlaceholderType { syntax }), 2908 PLACEHOLDER_TYPE => Type::PlaceholderType(PlaceholderType { syntax }),
2909 FN_POINTER_TYPE => TypeRef::FnPointerType(FnPointerType { syntax }), 2909 FN_POINTER_TYPE => Type::FnPointerType(FnPointerType { syntax }),
2910 FOR_TYPE => TypeRef::ForType(ForType { syntax }), 2910 FOR_TYPE => Type::ForType(ForType { syntax }),
2911 IMPL_TRAIT_TYPE => TypeRef::ImplTraitType(ImplTraitType { syntax }), 2911 IMPL_TRAIT_TYPE => Type::ImplTraitType(ImplTraitType { syntax }),
2912 DYN_TRAIT_TYPE => TypeRef::DynTraitType(DynTraitType { syntax }), 2912 DYN_TRAIT_TYPE => Type::DynTraitType(DynTraitType { syntax }),
2913 _ => return None, 2913 _ => return None,
2914 }; 2914 };
2915 Some(res) 2915 Some(res)
2916 } 2916 }
2917 fn syntax(&self) -> &SyntaxNode { 2917 fn syntax(&self) -> &SyntaxNode {
2918 match self { 2918 match self {
2919 TypeRef::ParenType(it) => &it.syntax, 2919 Type::ParenType(it) => &it.syntax,
2920 TypeRef::TupleType(it) => &it.syntax, 2920 Type::TupleType(it) => &it.syntax,
2921 TypeRef::NeverType(it) => &it.syntax, 2921 Type::NeverType(it) => &it.syntax,
2922 TypeRef::PathType(it) => &it.syntax, 2922 Type::PathType(it) => &it.syntax,
2923 TypeRef::PointerType(it) => &it.syntax, 2923 Type::PointerType(it) => &it.syntax,
2924 TypeRef::ArrayType(it) => &it.syntax, 2924 Type::ArrayType(it) => &it.syntax,
2925 TypeRef::SliceType(it) => &it.syntax, 2925 Type::SliceType(it) => &it.syntax,
2926 TypeRef::ReferenceType(it) => &it.syntax, 2926 Type::ReferenceType(it) => &it.syntax,
2927 TypeRef::PlaceholderType(it) => &it.syntax, 2927 Type::PlaceholderType(it) => &it.syntax,
2928 TypeRef::FnPointerType(it) => &it.syntax, 2928 Type::FnPointerType(it) => &it.syntax,
2929 TypeRef::ForType(it) => &it.syntax, 2929 Type::ForType(it) => &it.syntax,
2930 TypeRef::ImplTraitType(it) => &it.syntax, 2930 Type::ImplTraitType(it) => &it.syntax,
2931 TypeRef::DynTraitType(it) => &it.syntax, 2931 Type::DynTraitType(it) => &it.syntax,
2932 } 2932 }
2933 } 2933 }
2934} 2934}
@@ -3234,6 +3234,39 @@ impl AstNode for Expr {
3234 } 3234 }
3235 } 3235 }
3236} 3236}
3237impl From<Struct> for AdtDef {
3238 fn from(node: Struct) -> AdtDef { AdtDef::Struct(node) }
3239}
3240impl From<Enum> for AdtDef {
3241 fn from(node: Enum) -> AdtDef { AdtDef::Enum(node) }
3242}
3243impl From<Union> for AdtDef {
3244 fn from(node: Union) -> AdtDef { AdtDef::Union(node) }
3245}
3246impl AstNode for AdtDef {
3247 fn can_cast(kind: SyntaxKind) -> bool {
3248 match kind {
3249 STRUCT | ENUM | UNION => true,
3250 _ => false,
3251 }
3252 }
3253 fn cast(syntax: SyntaxNode) -> Option<Self> {
3254 let res = match syntax.kind() {
3255 STRUCT => AdtDef::Struct(Struct { syntax }),
3256 ENUM => AdtDef::Enum(Enum { syntax }),
3257 UNION => AdtDef::Union(Union { syntax }),
3258 _ => return None,
3259 };
3260 Some(res)
3261 }
3262 fn syntax(&self) -> &SyntaxNode {
3263 match self {
3264 AdtDef::Struct(it) => &it.syntax,
3265 AdtDef::Enum(it) => &it.syntax,
3266 AdtDef::Union(it) => &it.syntax,
3267 }
3268 }
3269}
3237impl From<Fn> for AssocItem { 3270impl From<Fn> for AssocItem {
3238 fn from(node: Fn) -> AssocItem { AssocItem::Fn(node) } 3271 fn from(node: Fn) -> AssocItem { AssocItem::Fn(node) }
3239} 3272}
@@ -3366,45 +3399,12 @@ impl AstNode for Stmt {
3366 } 3399 }
3367 } 3400 }
3368} 3401}
3369impl From<Struct> for AdtDef {
3370 fn from(node: Struct) -> AdtDef { AdtDef::Struct(node) }
3371}
3372impl From<Enum> for AdtDef {
3373 fn from(node: Enum) -> AdtDef { AdtDef::Enum(node) }
3374}
3375impl From<Union> for AdtDef {
3376 fn from(node: Union) -> AdtDef { AdtDef::Union(node) }
3377}
3378impl AstNode for AdtDef {
3379 fn can_cast(kind: SyntaxKind) -> bool {
3380 match kind {
3381 STRUCT | ENUM | UNION => true,
3382 _ => false,
3383 }
3384 }
3385 fn cast(syntax: SyntaxNode) -> Option<Self> {
3386 let res = match syntax.kind() {
3387 STRUCT => AdtDef::Struct(Struct { syntax }),
3388 ENUM => AdtDef::Enum(Enum { syntax }),
3389 UNION => AdtDef::Union(Union { syntax }),
3390 _ => return None,
3391 };
3392 Some(res)
3393 }
3394 fn syntax(&self) -> &SyntaxNode {
3395 match self {
3396 AdtDef::Struct(it) => &it.syntax,
3397 AdtDef::Enum(it) => &it.syntax,
3398 AdtDef::Union(it) => &it.syntax,
3399 }
3400 }
3401}
3402impl std::fmt::Display for Item { 3402impl std::fmt::Display for Item {
3403 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 3403 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3404 std::fmt::Display::fmt(self.syntax(), f) 3404 std::fmt::Display::fmt(self.syntax(), f)
3405 } 3405 }
3406} 3406}
3407impl std::fmt::Display for TypeRef { 3407impl std::fmt::Display for Type {
3408 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 3408 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3409 std::fmt::Display::fmt(self.syntax(), f) 3409 std::fmt::Display::fmt(self.syntax(), f)
3410 } 3410 }
@@ -3424,27 +3424,27 @@ impl std::fmt::Display for Expr {
3424 std::fmt::Display::fmt(self.syntax(), f) 3424 std::fmt::Display::fmt(self.syntax(), f)
3425 } 3425 }
3426} 3426}
3427impl std::fmt::Display for AssocItem { 3427impl std::fmt::Display for AdtDef {
3428 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 3428 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3429 std::fmt::Display::fmt(self.syntax(), f) 3429 std::fmt::Display::fmt(self.syntax(), f)
3430 } 3430 }
3431} 3431}
3432impl std::fmt::Display for ExternItem { 3432impl std::fmt::Display for AssocItem {
3433 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 3433 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3434 std::fmt::Display::fmt(self.syntax(), f) 3434 std::fmt::Display::fmt(self.syntax(), f)
3435 } 3435 }
3436} 3436}
3437impl std::fmt::Display for GenericParam { 3437impl std::fmt::Display for ExternItem {
3438 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 3438 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3439 std::fmt::Display::fmt(self.syntax(), f) 3439 std::fmt::Display::fmt(self.syntax(), f)
3440 } 3440 }
3441} 3441}
3442impl std::fmt::Display for Stmt { 3442impl std::fmt::Display for GenericParam {
3443 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 3443 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3444 std::fmt::Display::fmt(self.syntax(), f) 3444 std::fmt::Display::fmt(self.syntax(), f)
3445 } 3445 }
3446} 3446}
3447impl std::fmt::Display for AdtDef { 3447impl std::fmt::Display for Stmt {
3448 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { 3448 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3449 std::fmt::Display::fmt(self.syntax(), f) 3449 std::fmt::Display::fmt(self.syntax(), f)
3450 } 3450 }
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-10 15:53:04 +0000