diff options
| -rw-r--r-- | crates/ra_syntax/src/ast/generated/nodes.rs | 2924 | ||||
| -rw-r--r-- | xtask/src/codegen/gen_syntax.rs | 250 |
2 files changed, 1592 insertions, 1582 deletions
diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs index 188f0df968e..2cb3ad01145 100644 --- a/crates/ra_syntax/src/ast/generated/nodes.rs +++ b/crates/ra_syntax/src/ast/generated/nodes.rs @@ -10,17 +10,6 @@ use crate::{ pub struct SourceFile { pub(crate) syntax: SyntaxNode, } -impl AstNode for SourceFile { - fn can_cast(kind: SyntaxKind) -> bool { kind == SOURCE_FILE } - fn cast(syntax: SyntaxNode) -> Option<Self> { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl ast::ModuleItemOwner for SourceFile {} impl ast::AttrsOwner for SourceFile {} impl SourceFile { @@ -31,17 +20,6 @@ impl SourceFile { pub struct FnDef { pub(crate) syntax: SyntaxNode, } -impl AstNode for FnDef { - fn can_cast(kind: SyntaxKind) -> bool { kind == FN_DEF } - fn cast(syntax: SyntaxNode) -> Option<Self> { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl ast::VisibilityOwner for FnDef {} impl ast::NameOwner for FnDef {} impl ast::TypeParamsOwner for FnDef {} @@ -64,17 +42,6 @@ impl FnDef { pub struct RetType { pub(crate) syntax: SyntaxNode, } -impl AstNode for RetType { - fn can_cast(kind: SyntaxKind) -> bool { kind == RET_TYPE } - fn cast(syntax: SyntaxNode) -> Option<Self> { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl RetType { pub fn thin_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![->]) } pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } @@ -84,17 +51,6 @@ impl RetType { pub struct StructDef { pub(crate) syntax: SyntaxNode, } -impl AstNode for StructDef { - fn can_cast(kind: SyntaxKind) -> bool { kind == STRUCT_DEF } - fn cast(syntax: SyntaxNode) -> Option<Self> { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl ast::VisibilityOwner for StructDef {} impl ast::NameOwner for StructDef {} impl ast::TypeParamsOwner for StructDef {} @@ -110,17 +66,6 @@ impl StructDef { pub struct UnionDef { pub(crate) syntax: SyntaxNode, } -impl AstNode for UnionDef { - fn can_cast(kind: SyntaxKind) -> bool { kind == UNION_DEF } - fn cast(syntax: SyntaxNode) -> Option<Self> { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl ast::VisibilityOwner for UnionDef {} impl ast::NameOwner for UnionDef {} impl ast::TypeParamsOwner for UnionDef {} @@ -137,17 +82,6 @@ impl UnionDef { pub struct RecordFieldDefList { pub(crate) syntax: SyntaxNode, } -impl AstNode for RecordFieldDefList { - fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_DEF_LIST } - fn cast(syntax: SyntaxNode) -> Option<Self> { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl RecordFieldDefList { pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } pub fn fields(&self) -> AstChildren<RecordFieldDef> { support::children(&self.syntax) } @@ -158,17 +92,6 @@ impl RecordFieldDefList { pub struct RecordFieldDef { pub(crate) syntax: SyntaxNode, } -impl AstNode for RecordFieldDef { - fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_DEF } - fn cast(syntax: SyntaxNode) -> Option<Self> { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl ast::VisibilityOwner for RecordFieldDef {} impl ast::NameOwner for RecordFieldDef {} impl ast::AttrsOwner for RecordFieldDef {} @@ -180,17 +103,6 @@ impl RecordFieldDef {} pub struct TupleFieldDefList { pub(crate) syntax: SyntaxNode, } -impl AstNode for TupleFieldDefList { - fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD_DEF_LIST } - fn cast(syntax: SyntaxNode) -> Option<Self> { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl TupleFieldDefList { pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } pub fn fields(&self) -> AstChildren<TupleFieldDef> { support::children(&self.syntax) } @@ -201,17 +113,6 @@ impl TupleFieldDefList { pub struct TupleFieldDef { pub(crate) syntax: SyntaxNode, } -impl AstNode for TupleFieldDef { - fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD_DEF } - fn cast(syntax: SyntaxNode) -> Option<Self> { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl ast::VisibilityOwner for TupleFieldDef {} impl ast::AttrsOwner for TupleFieldDef {} impl TupleFieldDef { @@ -222,17 +123,6 @@ impl TupleFieldDef { pub struct EnumDef { pub(crate) syntax: SyntaxNode, } -impl AstNode for EnumDef { - fn can_cast(kind: SyntaxKind) -> bool { kind == ENUM_DEF } - fn cast(syntax: SyntaxNode) -> Option<Self> { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl ast::VisibilityOwner for EnumDef {} impl ast::NameOwner for EnumDef {} impl ast::TypeParamsOwner for EnumDef {} @@ -247,17 +137,6 @@ impl EnumDef { pub struct EnumVariantList { pub(crate) syntax: SyntaxNode, } -impl AstNode for EnumVariantList { - fn can_cast(kind: SyntaxKind) -> bool { kind == ENUM_VARIANT_LIST } - fn cast(syntax: SyntaxNode) -> Option<Self> { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl EnumVariantList { pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } pub fn variants(&self) -> AstChildren<EnumVariant> { support::children(&self.syntax) } @@ -268,17 +147,6 @@ impl EnumVariantList { pub struct EnumVariant { pub(crate) syntax: SyntaxNode, } -impl AstNode for EnumVariant { - fn can_cast(kind: SyntaxKind) -> bool { kind == ENUM_VARIANT } - fn cast(syntax: SyntaxNode) -> Option<Self> { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl ast::VisibilityOwner for EnumVariant {} impl ast::NameOwner for EnumVariant {} impl ast::DocCommentsOwner for EnumVariant {} @@ -293,17 +161,6 @@ impl EnumVariant { pub struct TraitDef { pub(crate) syntax: SyntaxNode, } -impl AstNode for TraitDef { - fn can_cast(kind: SyntaxKind) -> bool { kind == TRAIT_DEF } - fn cast(syntax: SyntaxNode) -> Option<Self> { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl ast::VisibilityOwner for TraitDef {} impl ast::NameOwner for TraitDef {} impl ast::AttrsOwner for TraitDef {} @@ -321,17 +178,6 @@ impl TraitDef { pub struct Module { pub(crate) syntax: SyntaxNode, } -impl AstNode for Module { - fn can_cast(kind: SyntaxKind) -> bool { kind == MODULE } - fn cast(syntax: SyntaxNode) -> Option<Self> { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl ast::VisibilityOwner for Module {} impl ast::NameOwner for Module {} impl ast::AttrsOwner for Module {} @@ -346,17 +192,6 @@ impl Module { pub struct ItemList { pub(crate) syntax: SyntaxNode, } -impl AstNode for ItemList { - fn can_cast(kind: SyntaxKind) -> bool { kind == ITEM_LIST } - fn cast(syntax: SyntaxNode) -> Option<Self> { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl ast::ModuleItemOwner for ItemList {} impl ItemList { pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } @@ -368,17 +203,6 @@ impl ItemList { pub struct ConstDef { pub(crate) syntax: SyntaxNode, } -impl AstNode for ConstDef { - fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_DEF } - fn cast(syntax: SyntaxNode) -> Option<Self> { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl ast::VisibilityOwner for ConstDef {} impl ast::NameOwner for ConstDef {} impl ast::TypeParamsOwner for ConstDef {} @@ -397,17 +221,6 @@ impl ConstDef { pub struct StaticDef { pub(crate) syntax: SyntaxNode, } -impl AstNode for StaticDef { - fn can_cast(kind: SyntaxKind) -> bool { kind == STATIC_DEF } - fn cast(syntax: SyntaxNode) -> Option<Self> { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl ast::VisibilityOwner for StaticDef {} impl ast::NameOwner for StaticDef {} impl ast::TypeParamsOwner for StaticDef {} @@ -426,17 +239,6 @@ impl StaticDef { pub struct TypeAliasDef { pub(crate) syntax: SyntaxNode, } -impl AstNode for TypeAliasDef { - fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ALIAS_DEF } - fn cast(syntax: SyntaxNode) -> Option<Self> { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl ast::VisibilityOwner for TypeAliasDef {} impl ast::NameOwner for TypeAliasDef {} impl ast::TypeParamsOwner for TypeAliasDef {} @@ -455,17 +257,6 @@ impl TypeAliasDef { pub struct ImplDef { pub(crate) syntax: SyntaxNode, } -impl AstNode for ImplDef { - fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL_DEF } - fn cast(syntax: SyntaxNode) -> Option<Self> { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } -} impl ast::TypeParamsOwner for ImplDef {} impl ast::AttrsOwner for ImplDef {} impl ImplDef { @@ -482,8 +273,1262 @@ impl ImplDef { pub struct ParenType { pub(crate) syntax: SyntaxNode, } -impl AstNode for ParenType { - fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_TYPE } +impl ParenType { + pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } + pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TupleType { + pub(crate) syntax: SyntaxNode, +} +impl TupleType { + pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + pub fn fields(&self) -> AstChildren<TypeRef> { support::children(&self.syntax) } + pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct NeverType { + pub(crate) syntax: SyntaxNode, +} +impl NeverType { + pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct PathType { + pub(crate) syntax: SyntaxNode, +} +impl PathType { + pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct PointerType { + pub(crate) syntax: SyntaxNode, +} +impl PointerType { + pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) } + pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } + pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } + pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ArrayType { + pub(crate) syntax: SyntaxNode, +} +impl ArrayType { + pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } + pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } + pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } + pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SliceType { + pub(crate) syntax: SyntaxNode, +} +impl SliceType { + pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } + pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } + pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ReferenceType { + pub(crate) syntax: SyntaxNode, +} +impl ReferenceType { + pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) } + pub fn lifetime_token(&self) -> Option<SyntaxToken> { + support::token(&self.syntax, T![lifetime]) + } + pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } + pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct PlaceholderType { + pub(crate) syntax: SyntaxNode, +} +impl PlaceholderType { + pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct FnPointerType { + pub(crate) syntax: SyntaxNode, +} +impl FnPointerType { + pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) } + pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) } + pub fn fn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![fn]) } + pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) } + pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ForType { + pub(crate) syntax: SyntaxNode, +} +impl ForType { + pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) } + pub fn type_param_list(&self) -> Option<TypeParamList> { support::child(&self.syntax) } + pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ImplTraitType { + pub(crate) syntax: SyntaxNode, +} +impl ast::TypeBoundsOwner for ImplTraitType {} +impl ImplTraitType { + pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DynTraitType { + pub(crate) syntax: SyntaxNode, +} +impl ast::TypeBoundsOwner for DynTraitType {} +impl DynTraitType { + pub fn dyn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![dyn]) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TupleExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for TupleExpr {} +impl TupleExpr { + pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) } + pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ArrayExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for ArrayExpr {} +impl ArrayExpr { + pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } + pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) } + pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } + pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ParenExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for ParenExpr {} +impl ParenExpr { + pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct PathExpr { + pub(crate) syntax: SyntaxNode, +} +impl PathExpr { + pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct LambdaExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for LambdaExpr {} +impl LambdaExpr { + pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) } + pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) } + pub fn move_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![move]) } + pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) } + pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } + pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct IfExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for IfExpr {} +impl IfExpr { + pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) } + pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct LoopExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for LoopExpr {} +impl ast::LoopBodyOwner for LoopExpr {} +impl LoopExpr { + pub fn loop_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![loop]) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TryBlockExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for TryBlockExpr {} +impl TryBlockExpr { + pub fn try_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![try]) } + pub fn body(&self) -> Option<BlockExpr> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ForExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for ForExpr {} +impl ast::LoopBodyOwner for ForExpr {} +impl ForExpr { + pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) } + pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) } + pub fn iterable(&self) -> Option<Expr> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct WhileExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for WhileExpr {} +impl ast::LoopBodyOwner for WhileExpr {} +impl WhileExpr { + pub fn while_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![while]) } + pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ContinueExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for ContinueExpr {} +impl ContinueExpr { + pub fn continue_token(&self) -> Option<SyntaxToken> { + support::token(&self.syntax, T![continue]) + } + pub fn lifetime_token(&self) -> Option<SyntaxToken> { + support::token(&self.syntax, T![lifetime]) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct BreakExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for BreakExpr {} +impl BreakExpr { + pub fn break_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![break]) } + pub fn lifetime_token(&self) -> Option<SyntaxToken> { + support::token(&self.syntax, T![lifetime]) + } + pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Label { + pub(crate) syntax: SyntaxNode, +} +impl Label { + pub fn lifetime_token(&self) -> Option<SyntaxToken> { + support::token(&self.syntax, T![lifetime]) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct BlockExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for BlockExpr {} +impl BlockExpr { + pub fn label(&self) -> Option<Label> { support::child(&self.syntax) } + pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) } + pub fn block(&self) -> Option<Block> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ReturnExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for ReturnExpr {} +impl ReturnExpr { + pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CallExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::ArgListOwner for CallExpr {} +impl CallExpr { + pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct MethodCallExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for MethodCallExpr {} +impl ast::ArgListOwner for MethodCallExpr {} +impl MethodCallExpr { + pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) } + pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } + pub fn type_arg_list(&self) -> Option<TypeArgList> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct IndexExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for IndexExpr {} +impl IndexExpr { + pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } + pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct FieldExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for FieldExpr {} +impl FieldExpr { + pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) } + pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AwaitExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for AwaitExpr {} +impl AwaitExpr { + pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) } + pub fn await_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![await]) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TryExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for TryExpr {} +impl TryExpr { + pub fn try_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![try]) } + pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CastExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for CastExpr {} +impl CastExpr { + pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) } + pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RefExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for RefExpr {} +impl RefExpr { + pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) } + pub fn raw_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![raw]) } + pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } + pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct PrefixExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for PrefixExpr {} +impl PrefixExpr { + pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct BoxExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for BoxExpr {} +impl BoxExpr { + pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) } + pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RangeExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for RangeExpr {} +impl RangeExpr {} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct BinExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for BinExpr {} +impl BinExpr {} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Literal { + pub(crate) syntax: SyntaxNode, +} +impl Literal {} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct MatchExpr { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for MatchExpr {} +impl MatchExpr { + pub fn match_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![match]) } + pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + pub fn match_arm_list(&self) -> Option<MatchArmList> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct MatchArmList { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for MatchArmList {} +impl MatchArmList { + pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + pub fn arms(&self) -> AstChildren<MatchArm> { support::children(&self.syntax) } + pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct MatchArm { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for MatchArm {} +impl MatchArm { + pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + pub fn guard(&self) -> Option<MatchGuard> { support::child(&self.syntax) } + pub fn fat_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=>]) } + pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct MatchGuard { + pub(crate) syntax: SyntaxNode, +} +impl MatchGuard { + pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) } + pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RecordLit { + pub(crate) syntax: SyntaxNode, +} +impl RecordLit { + pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } + pub fn record_field_list(&self) -> Option<RecordFieldList> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RecordFieldList { + pub(crate) syntax: SyntaxNode, +} +impl RecordFieldList { + pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + pub fn fields(&self) -> AstChildren<RecordField> { support::children(&self.syntax) } + pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) } + pub fn spread(&self) -> Option<Expr> { support::child(&self.syntax) } + pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RecordField { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for RecordField {} +impl RecordField { + pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } + pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } + pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct OrPat { + pub(crate) syntax: SyntaxNode, +} +impl OrPat { + pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ParenPat { + pub(crate) syntax: SyntaxNode, +} +impl ParenPat { + pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RefPat { + pub(crate) syntax: SyntaxNode, +} +impl RefPat { + pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) } + pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } + pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct BoxPat { + pub(crate) syntax: SyntaxNode, +} +impl BoxPat { + pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) } + pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct BindPat { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for BindPat {} +impl ast::NameOwner for BindPat {} +impl BindPat { + pub fn ref_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ref]) } + pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } + pub fn at_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![@]) } + pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct PlaceholderPat { + pub(crate) syntax: SyntaxNode, +} +impl PlaceholderPat { + pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DotDotPat { + pub(crate) syntax: SyntaxNode, +} +impl DotDotPat { + pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct PathPat { + pub(crate) syntax: SyntaxNode, +} +impl PathPat { + pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SlicePat { + pub(crate) syntax: SyntaxNode, +} +impl SlicePat { + pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } + pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) } + pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RangePat { + pub(crate) syntax: SyntaxNode, +} +impl RangePat {} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct LiteralPat { + pub(crate) syntax: SyntaxNode, +} +impl LiteralPat { + pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct MacroPat { + pub(crate) syntax: SyntaxNode, +} +impl MacroPat { + pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RecordPat { + pub(crate) syntax: SyntaxNode, +} +impl RecordPat { + pub fn record_field_pat_list(&self) -> Option<RecordFieldPatList> { + support::child(&self.syntax) + } + pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RecordFieldPatList { + pub(crate) syntax: SyntaxNode, +} +impl RecordFieldPatList { + pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + pub fn pats(&self) -> AstChildren<RecordInnerPat> { support::children(&self.syntax) } + pub fn record_field_pats(&self) -> AstChildren<RecordFieldPat> { + support::children(&self.syntax) + } + pub fn bind_pats(&self) -> AstChildren<BindPat> { support::children(&self.syntax) } + pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) } + pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RecordFieldPat { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for RecordFieldPat {} +impl RecordFieldPat { + pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } + pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } + pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TupleStructPat { + pub(crate) syntax: SyntaxNode, +} +impl TupleStructPat { + pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } + pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) } + pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TuplePat { + pub(crate) syntax: SyntaxNode, +} +impl TuplePat { + pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) } + pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Visibility { + pub(crate) syntax: SyntaxNode, +} +impl Visibility { + pub fn pub_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![pub]) } + pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) } + pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) } + pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Name { + pub(crate) syntax: SyntaxNode, +} +impl Name { + pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct NameRef { + pub(crate) syntax: SyntaxNode, +} +impl NameRef {} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct MacroCall { + pub(crate) syntax: SyntaxNode, +} +impl ast::NameOwner for MacroCall {} +impl ast::AttrsOwner for MacroCall {} +impl ast::DocCommentsOwner for MacroCall {} +impl MacroCall { + pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } + pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) } + pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) } + pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Attr { + pub(crate) syntax: SyntaxNode, +} +impl Attr { + pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) } + pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) } + pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } + pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } + pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + pub fn input(&self) -> Option<AttrInput> { support::child(&self.syntax) } + pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TokenTree { + pub(crate) syntax: SyntaxNode, +} +impl TokenTree {} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TypeParamList { + pub(crate) syntax: SyntaxNode, +} +impl TypeParamList { + pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) } + pub fn generic_params(&self) -> AstChildren<GenericParam> { support::children(&self.syntax) } + pub fn type_params(&self) -> AstChildren<TypeParam> { support::children(&self.syntax) } + pub fn lifetime_params(&self) -> AstChildren<LifetimeParam> { support::children(&self.syntax) } + pub fn const_params(&self) -> AstChildren<ConstParam> { support::children(&self.syntax) } + pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TypeParam { + pub(crate) syntax: SyntaxNode, +} +impl ast::NameOwner for TypeParam {} +impl ast::AttrsOwner for TypeParam {} +impl ast::TypeBoundsOwner for TypeParam {} +impl TypeParam { + pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + pub fn default_type(&self) -> Option<TypeRef> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ConstParam { + pub(crate) syntax: SyntaxNode, +} +impl ast::NameOwner for ConstParam {} +impl ast::AttrsOwner for ConstParam {} +impl ast::TypeAscriptionOwner for ConstParam {} +impl ConstParam { + pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + pub fn default_val(&self) -> Option<Expr> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct LifetimeParam { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for LifetimeParam {} +impl LifetimeParam { + pub fn lifetime_token(&self) -> Option<SyntaxToken> { + support::token(&self.syntax, T![lifetime]) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TypeBound { + pub(crate) syntax: SyntaxNode, +} +impl TypeBound { + pub fn lifetime_token(&self) -> Option<SyntaxToken> { + support::token(&self.syntax, T![lifetime]) + } + pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } + pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TypeBoundList { + pub(crate) syntax: SyntaxNode, +} +impl TypeBoundList { + pub fn bounds(&self) -> AstChildren<TypeBound> { support::children(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct WherePred { + pub(crate) syntax: SyntaxNode, +} +impl ast::TypeBoundsOwner for WherePred {} +impl WherePred { + pub fn lifetime_token(&self) -> Option<SyntaxToken> { + support::token(&self.syntax, T![lifetime]) + } + pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct WhereClause { + pub(crate) syntax: SyntaxNode, +} +impl WhereClause { + pub fn where_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![where]) } + pub fn predicates(&self) -> AstChildren<WherePred> { support::children(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Abi { + pub(crate) syntax: SyntaxNode, +} +impl Abi {} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ExprStmt { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for ExprStmt {} +impl ExprStmt { + pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct LetStmt { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for LetStmt {} +impl ast::TypeAscriptionOwner for LetStmt {} +impl LetStmt { + pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) } + pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + pub fn initializer(&self) -> Option<Expr> { support::child(&self.syntax) } + pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Condition { + pub(crate) syntax: SyntaxNode, +} +impl Condition { + pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) } + pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Block { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for Block {} +impl ast::ModuleItemOwner for Block {} +impl Block { + pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) } + pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ParamList { + pub(crate) syntax: SyntaxNode, +} +impl ParamList { + pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + pub fn self_param(&self) -> Option<SelfParam> { support::child(&self.syntax) } + pub fn params(&self) -> AstChildren<Param> { support::children(&self.syntax) } + pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SelfParam { + pub(crate) syntax: SyntaxNode, +} +impl ast::TypeAscriptionOwner for SelfParam {} +impl ast::AttrsOwner for SelfParam {} +impl SelfParam { + pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) } + pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } + pub fn lifetime_token(&self) -> Option<SyntaxToken> { + support::token(&self.syntax, T![lifetime]) + } + pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Param { + pub(crate) syntax: SyntaxNode, +} +impl ast::TypeAscriptionOwner for Param {} +impl ast::AttrsOwner for Param {} +impl Param { + pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + pub fn dotdotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![...]) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct UseItem { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for UseItem {} +impl ast::VisibilityOwner for UseItem {} +impl UseItem { + pub fn use_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![use]) } + pub fn use_tree(&self) -> Option<UseTree> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct UseTree { + pub(crate) syntax: SyntaxNode, +} +impl UseTree { + pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } + pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) } + pub fn use_tree_list(&self) -> Option<UseTreeList> { support::child(&self.syntax) } + pub fn alias(&self) -> Option<Alias> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Alias { + pub(crate) syntax: SyntaxNode, +} +impl ast::NameOwner for Alias {} +impl Alias { + pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct UseTreeList { + pub(crate) syntax: SyntaxNode, +} +impl UseTreeList { + pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + pub fn use_trees(&self) -> AstChildren<UseTree> { support::children(&self.syntax) } + pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ExternCrateItem { + pub(crate) syntax: SyntaxNode, +} +impl ast::AttrsOwner for ExternCrateItem {} +impl ast::VisibilityOwner for ExternCrateItem {} +impl ExternCrateItem { + pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) } + pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) } + pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } + pub fn alias(&self) -> Option<Alias> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ArgList { + pub(crate) syntax: SyntaxNode, +} +impl ArgList { + pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + pub fn args(&self) -> AstChildren<Expr> { support::children(&self.syntax) } + pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Path { + pub(crate) syntax: SyntaxNode, +} +impl Path { + pub fn segment(&self) -> Option<PathSegment> { support::child(&self.syntax) } + pub fn qualifier(&self) -> Option<Path> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct PathSegment { + pub(crate) syntax: SyntaxNode, +} +impl PathSegment { + pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) } + pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) } + pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } + pub fn type_arg_list(&self) -> Option<TypeArgList> { support::child(&self.syntax) } + pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) } + pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } + pub fn path_type(&self) -> Option<PathType> { support::child(&self.syntax) } + pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TypeArgList { + pub(crate) syntax: SyntaxNode, +} +impl TypeArgList { + pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) } + pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) } + pub fn generic_args(&self) -> AstChildren<GenericArg> { support::children(&self.syntax) } + pub fn type_args(&self) -> AstChildren<TypeArg> { support::children(&self.syntax) } + pub fn lifetime_args(&self) -> AstChildren<LifetimeArg> { support::children(&self.syntax) } + pub fn assoc_type_args(&self) -> AstChildren<AssocTypeArg> { support::children(&self.syntax) } + pub fn const_args(&self) -> AstChildren<ConstArg> { support::children(&self.syntax) } + pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TypeArg { + pub(crate) syntax: SyntaxNode, +} +impl TypeArg { + pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AssocTypeArg { + pub(crate) syntax: SyntaxNode, +} +impl ast::TypeBoundsOwner for AssocTypeArg {} +impl AssocTypeArg { + pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } + pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct LifetimeArg { + pub(crate) syntax: SyntaxNode, +} +impl LifetimeArg { + pub fn lifetime_token(&self) -> Option<SyntaxToken> { + support::token(&self.syntax, T![lifetime]) + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ConstArg { + pub(crate) syntax: SyntaxNode, +} +impl ConstArg { + pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) } + pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct MacroItems { + pub(crate) syntax: SyntaxNode, +} +impl ast::ModuleItemOwner for MacroItems {} +impl MacroItems {} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct MacroStmts { + pub(crate) syntax: SyntaxNode, +} +impl MacroStmts { + pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) } + pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ExternItemList { + pub(crate) syntax: SyntaxNode, +} +impl ast::ModuleItemOwner for ExternItemList {} +impl ExternItemList { + pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + pub fn extern_items(&self) -> AstChildren<ExternItem> { support::children(&self.syntax) } + pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ExternBlock { + pub(crate) syntax: SyntaxNode, +} +impl ExternBlock { + pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) } + pub fn extern_item_list(&self) -> Option<ExternItemList> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct MetaItem { + pub(crate) syntax: SyntaxNode, +} +impl MetaItem { + pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } + pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + pub fn attr_input(&self) -> Option<AttrInput> { support::child(&self.syntax) } + pub fn nested_meta_items(&self) -> AstChildren<MetaItem> { support::children(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct MacroDef { + pub(crate) syntax: SyntaxNode, +} +impl MacroDef { + pub fn name(&self) -> Option<Name> { support::child(&self.syntax) } + pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) } +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum NominalDef { + StructDef(StructDef), + EnumDef(EnumDef), + UnionDef(UnionDef), +} +impl ast::NameOwner for NominalDef {} +impl ast::TypeParamsOwner for NominalDef {} +impl ast::AttrsOwner for NominalDef {} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum GenericParam { + LifetimeParam(LifetimeParam), + TypeParam(TypeParam), + ConstParam(ConstParam), +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum GenericArg { + LifetimeArg(LifetimeArg), + TypeArg(TypeArg), + ConstArg(ConstArg), + AssocTypeArg(AssocTypeArg), +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum TypeRef { + ParenType(ParenType), + TupleType(TupleType), + NeverType(NeverType), + PathType(PathType), + PointerType(PointerType), + ArrayType(ArrayType), + SliceType(SliceType), + ReferenceType(ReferenceType), + PlaceholderType(PlaceholderType), + FnPointerType(FnPointerType), + ForType(ForType), + ImplTraitType(ImplTraitType), + DynTraitType(DynTraitType), +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum ModuleItem { + StructDef(StructDef), + UnionDef(UnionDef), + EnumDef(EnumDef), + FnDef(FnDef), + TraitDef(TraitDef), + TypeAliasDef(TypeAliasDef), + ImplDef(ImplDef), + UseItem(UseItem), + ExternCrateItem(ExternCrateItem), + ConstDef(ConstDef), + StaticDef(StaticDef), + Module(Module), + MacroCall(MacroCall), + ExternBlock(ExternBlock), +} +impl ast::NameOwner for ModuleItem {} +impl ast::AttrsOwner for ModuleItem {} +impl ast::VisibilityOwner for ModuleItem {} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum ImplItem { + FnDef(FnDef), + TypeAliasDef(TypeAliasDef), + ConstDef(ConstDef), +} +impl ast::NameOwner for ImplItem {} +impl ast::AttrsOwner for ImplItem {} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum ExternItem { + FnDef(FnDef), + StaticDef(StaticDef), +} +impl ast::NameOwner for ExternItem {} +impl ast::AttrsOwner for ExternItem {} +impl ast::VisibilityOwner for ExternItem {} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum Expr { + TupleExpr(TupleExpr), + ArrayExpr(ArrayExpr), + ParenExpr(ParenExpr), + PathExpr(PathExpr), + LambdaExpr(LambdaExpr), + IfExpr(IfExpr), + LoopExpr(LoopExpr), + ForExpr(ForExpr), + WhileExpr(WhileExpr), + ContinueExpr(ContinueExpr), + BreakExpr(BreakExpr), + Label(Label), + BlockExpr(BlockExpr), + ReturnExpr(ReturnExpr), + MatchExpr(MatchExpr), + RecordLit(RecordLit), + CallExpr(CallExpr), + IndexExpr(IndexExpr), + MethodCallExpr(MethodCallExpr), + FieldExpr(FieldExpr), + AwaitExpr(AwaitExpr), + TryExpr(TryExpr), + TryBlockExpr(TryBlockExpr), + CastExpr(CastExpr), + RefExpr(RefExpr), + PrefixExpr(PrefixExpr), + RangeExpr(RangeExpr), + BinExpr(BinExpr), + Literal(Literal), + MacroCall(MacroCall), + BoxExpr(BoxExpr), +} +impl ast::AttrsOwner for Expr {} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum Pat { + OrPat(OrPat), + ParenPat(ParenPat), + RefPat(RefPat), + BoxPat(BoxPat), + BindPat(BindPat), + PlaceholderPat(PlaceholderPat), + DotDotPat(DotDotPat), + PathPat(PathPat), + RecordPat(RecordPat), + TupleStructPat(TupleStructPat), + TuplePat(TuplePat), + SlicePat(SlicePat), + RangePat(RangePat), + LiteralPat(LiteralPat), + MacroPat(MacroPat), +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum RecordInnerPat { + RecordFieldPat(RecordFieldPat), + BindPat(BindPat), +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum AttrInput { + Literal(Literal), + TokenTree(TokenTree), +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum Stmt { + LetStmt(LetStmt), + ExprStmt(ExprStmt), +} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum FieldDefList { + RecordFieldDefList(RecordFieldDefList), + TupleFieldDefList(TupleFieldDefList), +} +impl AstNode for SourceFile { + fn can_cast(kind: SyntaxKind) -> bool { kind == SOURCE_FILE } fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -493,18 +1538,30 @@ impl AstNode for ParenType { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ParenType { - pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } - pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } - pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } +impl AstNode for FnDef { + fn can_cast(kind: SyntaxKind) -> bool { kind == FN_DEF } + fn cast(syntax: SyntaxNode) -> Option<Self> { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TupleType { - pub(crate) syntax: SyntaxNode, +impl AstNode for RetType { + fn can_cast(kind: SyntaxKind) -> bool { kind == RET_TYPE } + fn cast(syntax: SyntaxNode) -> Option<Self> { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for TupleType { - fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_TYPE } +impl AstNode for StructDef { + fn can_cast(kind: SyntaxKind) -> bool { kind == STRUCT_DEF } fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -514,18 +1571,30 @@ impl AstNode for TupleType { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl TupleType { - pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } - pub fn fields(&self) -> AstChildren<TypeRef> { support::children(&self.syntax) } - pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } +impl AstNode for UnionDef { + fn can_cast(kind: SyntaxKind) -> bool { kind == UNION_DEF } + fn cast(syntax: SyntaxNode) -> Option<Self> { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct NeverType { - pub(crate) syntax: SyntaxNode, +impl AstNode for RecordFieldDefList { + fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_DEF_LIST } + fn cast(syntax: SyntaxNode) -> Option<Self> { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for NeverType { - fn can_cast(kind: SyntaxKind) -> bool { kind == NEVER_TYPE } +impl AstNode for RecordFieldDef { + fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_DEF } fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -535,16 +1604,30 @@ impl AstNode for NeverType { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl NeverType { - pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) } +impl AstNode for TupleFieldDefList { + fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD_DEF_LIST } + fn cast(syntax: SyntaxNode) -> Option<Self> { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PathType { - pub(crate) syntax: SyntaxNode, +impl AstNode for TupleFieldDef { + fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD_DEF } + fn cast(syntax: SyntaxNode) -> Option<Self> { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for PathType { - fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_TYPE } +impl AstNode for EnumDef { + fn can_cast(kind: SyntaxKind) -> bool { kind == ENUM_DEF } fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -554,16 +1637,30 @@ impl AstNode for PathType { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl PathType { - pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } +impl AstNode for EnumVariantList { + fn can_cast(kind: SyntaxKind) -> bool { kind == ENUM_VARIANT_LIST } + fn cast(syntax: SyntaxNode) -> Option<Self> { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PointerType { - pub(crate) syntax: SyntaxNode, +impl AstNode for EnumVariant { + fn can_cast(kind: SyntaxKind) -> bool { kind == ENUM_VARIANT } + fn cast(syntax: SyntaxNode) -> Option<Self> { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for PointerType { - fn can_cast(kind: SyntaxKind) -> bool { kind == POINTER_TYPE } +impl AstNode for TraitDef { + fn can_cast(kind: SyntaxKind) -> bool { kind == TRAIT_DEF } fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -573,19 +1670,30 @@ impl AstNode for PointerType { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl PointerType { - pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) } - pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } - pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } - pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } +impl AstNode for Module { + fn can_cast(kind: SyntaxKind) -> bool { kind == MODULE } + fn cast(syntax: SyntaxNode) -> Option<Self> { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ArrayType { - pub(crate) syntax: SyntaxNode, +impl AstNode for ItemList { + fn can_cast(kind: SyntaxKind) -> bool { kind == ITEM_LIST } + fn cast(syntax: SyntaxNode) -> Option<Self> { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for ArrayType { - fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_TYPE } +impl AstNode for ConstDef { + fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_DEF } fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -595,20 +1703,30 @@ impl AstNode for ArrayType { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ArrayType { - pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } - pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } - pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } - pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } - pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } +impl AstNode for StaticDef { + fn can_cast(kind: SyntaxKind) -> bool { kind == STATIC_DEF } + fn cast(syntax: SyntaxNode) -> Option<Self> { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SliceType { - pub(crate) syntax: SyntaxNode, +impl AstNode for TypeAliasDef { + fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ALIAS_DEF } + fn cast(syntax: SyntaxNode) -> Option<Self> { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for SliceType { - fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_TYPE } +impl AstNode for ImplDef { + fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL_DEF } fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -618,18 +1736,30 @@ impl AstNode for SliceType { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl SliceType { - pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } - pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } - pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } +impl AstNode for ParenType { + fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_TYPE } + fn cast(syntax: SyntaxNode) -> Option<Self> { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ReferenceType { - pub(crate) syntax: SyntaxNode, +impl AstNode for TupleType { + fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_TYPE } + fn cast(syntax: SyntaxNode) -> Option<Self> { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for ReferenceType { - fn can_cast(kind: SyntaxKind) -> bool { kind == REFERENCE_TYPE } +impl AstNode for NeverType { + fn can_cast(kind: SyntaxKind) -> bool { kind == NEVER_TYPE } fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -639,21 +1769,30 @@ impl AstNode for ReferenceType { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ReferenceType { - pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) } - pub fn lifetime_token(&self) -> Option<SyntaxToken> { - support::token(&self.syntax, T![lifetime]) +impl AstNode for PathType { + fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_TYPE } + fn cast(syntax: SyntaxNode) -> Option<Self> { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } } - pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } - pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } + fn syntax(&self) -> &SyntaxNode { &self.syntax } } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PlaceholderType { - pub(crate) syntax: SyntaxNode, +impl AstNode for PointerType { + fn can_cast(kind: SyntaxKind) -> bool { kind == POINTER_TYPE } + fn cast(syntax: SyntaxNode) -> Option<Self> { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl AstNode for PlaceholderType { - fn can_cast(kind: SyntaxKind) -> bool { kind == PLACEHOLDER_TYPE } +impl AstNode for ArrayType { + fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_TYPE } fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -663,13 +1802,38 @@ impl AstNode for PlaceholderType { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl PlaceholderType { - pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) } +impl AstNode for SliceType { + fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_TYPE } + fn cast(syntax: SyntaxNode) -> Option<Self> { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct FnPointerType { - pub(crate) syntax: SyntaxNode, +impl AstNode for ReferenceType { + fn can_cast(kind: SyntaxKind) -> bool { kind == REFERENCE_TYPE } + fn cast(syntax: SyntaxNode) -> Option<Self> { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } +} +impl AstNode for PlaceholderType { + fn can_cast(kind: SyntaxKind) -> bool { kind == PLACEHOLDER_TYPE } + fn cast(syntax: SyntaxNode) -> Option<Self> { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for FnPointerType { fn can_cast(kind: SyntaxKind) -> bool { kind == FN_POINTER_TYPE } @@ -682,18 +1846,6 @@ impl AstNode for FnPointerType { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl FnPointerType { - pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) } - pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) } - pub fn fn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![fn]) } - pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) } - pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ForType { - pub(crate) syntax: SyntaxNode, -} impl AstNode for ForType { fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_TYPE } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -705,16 +1857,6 @@ impl AstNode for ForType { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ForType { - pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) } - pub fn type_param_list(&self) -> Option<TypeParamList> { support::child(&self.syntax) } - pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ImplTraitType { - pub(crate) syntax: SyntaxNode, -} impl AstNode for ImplTraitType { fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL_TRAIT_TYPE } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -726,15 +1868,6 @@ impl AstNode for ImplTraitType { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::TypeBoundsOwner for ImplTraitType {} -impl ImplTraitType { - pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct DynTraitType { - pub(crate) syntax: SyntaxNode, -} impl AstNode for DynTraitType { fn can_cast(kind: SyntaxKind) -> bool { kind == DYN_TRAIT_TYPE } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -746,15 +1879,6 @@ impl AstNode for DynTraitType { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::TypeBoundsOwner for DynTraitType {} -impl DynTraitType { - pub fn dyn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![dyn]) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TupleExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for TupleExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -766,17 +1890,6 @@ impl AstNode for TupleExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for TupleExpr {} -impl TupleExpr { - pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } - pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) } - pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ArrayExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for ArrayExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -788,18 +1901,6 @@ impl AstNode for ArrayExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for ArrayExpr {} -impl ArrayExpr { - pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } - pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) } - pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } - pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ParenExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for ParenExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -811,17 +1912,6 @@ impl AstNode for ParenExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for ParenExpr {} -impl ParenExpr { - pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } - pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } - pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PathExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for PathExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -833,14 +1923,6 @@ impl AstNode for PathExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl PathExpr { - pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LambdaExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for LambdaExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == LAMBDA_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -852,20 +1934,6 @@ impl AstNode for LambdaExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for LambdaExpr {} -impl LambdaExpr { - pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) } - pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) } - pub fn move_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![move]) } - pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) } - pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } - pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct IfExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for IfExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == IF_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -877,16 +1945,6 @@ impl AstNode for IfExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for IfExpr {} -impl IfExpr { - pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) } - pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LoopExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for LoopExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == LOOP_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -898,16 +1956,6 @@ impl AstNode for LoopExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for LoopExpr {} -impl ast::LoopBodyOwner for LoopExpr {} -impl LoopExpr { - pub fn loop_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![loop]) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TryBlockExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for TryBlockExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == TRY_BLOCK_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -919,16 +1967,6 @@ impl AstNode for TryBlockExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for TryBlockExpr {} -impl TryBlockExpr { - pub fn try_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![try]) } - pub fn body(&self) -> Option<BlockExpr> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ForExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for ForExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -940,19 +1978,6 @@ impl AstNode for ForExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for ForExpr {} -impl ast::LoopBodyOwner for ForExpr {} -impl ForExpr { - pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) } - pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } - pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) } - pub fn iterable(&self) -> Option<Expr> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WhileExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for WhileExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == WHILE_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -964,17 +1989,6 @@ impl AstNode for WhileExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for WhileExpr {} -impl ast::LoopBodyOwner for WhileExpr {} -impl WhileExpr { - pub fn while_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![while]) } - pub fn condition(&self) -> Option<Condition> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ContinueExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for ContinueExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == CONTINUE_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -986,20 +2000,6 @@ impl AstNode for ContinueExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for ContinueExpr {} -impl ContinueExpr { - pub fn continue_token(&self) -> Option<SyntaxToken> { - support::token(&self.syntax, T![continue]) - } - pub fn lifetime_token(&self) -> Option<SyntaxToken> { - support::token(&self.syntax, T![lifetime]) - } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct BreakExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for BreakExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == BREAK_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1011,19 +2011,6 @@ impl AstNode for BreakExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for BreakExpr {} -impl BreakExpr { - pub fn break_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![break]) } - pub fn lifetime_token(&self) -> Option<SyntaxToken> { - support::token(&self.syntax, T![lifetime]) - } - pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Label { - pub(crate) syntax: SyntaxNode, -} impl AstNode for Label { fn can_cast(kind: SyntaxKind) -> bool { kind == LABEL } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1035,16 +2022,6 @@ impl AstNode for Label { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl Label { - pub fn lifetime_token(&self) -> Option<SyntaxToken> { - support::token(&self.syntax, T![lifetime]) - } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct BlockExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for BlockExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == BLOCK_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1056,17 +2033,6 @@ impl AstNode for BlockExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for BlockExpr {} -impl BlockExpr { - pub fn label(&self) -> Option<Label> { support::child(&self.syntax) } - pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) } - pub fn block(&self) -> Option<Block> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ReturnExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for ReturnExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == RETURN_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1078,15 +2044,6 @@ impl AstNode for ReturnExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for ReturnExpr {} -impl ReturnExpr { - pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct CallExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for CallExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == CALL_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1098,15 +2055,6 @@ impl AstNode for CallExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::ArgListOwner for CallExpr {} -impl CallExpr { - pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MethodCallExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for MethodCallExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == METHOD_CALL_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1118,19 +2066,6 @@ impl AstNode for MethodCallExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for MethodCallExpr {} -impl ast::ArgListOwner for MethodCallExpr {} -impl MethodCallExpr { - pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } - pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) } - pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } - pub fn type_arg_list(&self) -> Option<TypeArgList> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct IndexExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for IndexExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == INDEX_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1142,16 +2077,6 @@ impl AstNode for IndexExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for IndexExpr {} -impl IndexExpr { - pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } - pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct FieldExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for FieldExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == FIELD_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1163,17 +2088,6 @@ impl AstNode for FieldExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for FieldExpr {} -impl FieldExpr { - pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } - pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) } - pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct AwaitExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for AwaitExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == AWAIT_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1185,17 +2099,6 @@ impl AstNode for AwaitExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for AwaitExpr {} -impl AwaitExpr { - pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } - pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) } - pub fn await_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![await]) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TryExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for TryExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == TRY_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1207,16 +2110,6 @@ impl AstNode for TryExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for TryExpr {} -impl TryExpr { - pub fn try_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![try]) } - pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct CastExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for CastExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == CAST_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1228,17 +2121,6 @@ impl AstNode for CastExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for CastExpr {} -impl CastExpr { - pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } - pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) } - pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RefExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for RefExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == REF_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1250,18 +2132,6 @@ impl AstNode for RefExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for RefExpr {} -impl RefExpr { - pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) } - pub fn raw_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![raw]) } - pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } - pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PrefixExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for PrefixExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == PREFIX_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1273,15 +2143,6 @@ impl AstNode for PrefixExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for PrefixExpr {} -impl PrefixExpr { - pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct BoxExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for BoxExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == BOX_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1293,16 +2154,6 @@ impl AstNode for BoxExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for BoxExpr {} -impl BoxExpr { - pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) } - pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RangeExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for RangeExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1314,13 +2165,6 @@ impl AstNode for RangeExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for RangeExpr {} -impl RangeExpr {} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct BinExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for BinExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == BIN_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1332,13 +2176,6 @@ impl AstNode for BinExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for BinExpr {} -impl BinExpr {} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Literal { - pub(crate) syntax: SyntaxNode, -} impl AstNode for Literal { fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1350,12 +2187,6 @@ impl AstNode for Literal { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl Literal {} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MatchExpr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for MatchExpr { fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_EXPR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1367,17 +2198,6 @@ impl AstNode for MatchExpr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for MatchExpr {} -impl MatchExpr { - pub fn match_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![match]) } - pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } - pub fn match_arm_list(&self) -> Option<MatchArmList> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MatchArmList { - pub(crate) syntax: SyntaxNode, -} impl AstNode for MatchArmList { fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM_LIST } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1389,17 +2209,6 @@ impl AstNode for MatchArmList { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for MatchArmList {} -impl MatchArmList { - pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } - pub fn arms(&self) -> AstChildren<MatchArm> { support::children(&self.syntax) } - pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MatchArm { - pub(crate) syntax: SyntaxNode, -} impl AstNode for MatchArm { fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1411,18 +2220,6 @@ impl AstNode for MatchArm { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for MatchArm {} -impl MatchArm { - pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } - pub fn guard(&self) -> Option<MatchGuard> { support::child(&self.syntax) } - pub fn fat_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=>]) } - pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MatchGuard { - pub(crate) syntax: SyntaxNode, -} impl AstNode for MatchGuard { fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_GUARD } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1434,15 +2231,6 @@ impl AstNode for MatchGuard { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl MatchGuard { - pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) } - pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordLit { - pub(crate) syntax: SyntaxNode, -} impl AstNode for RecordLit { fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_LIT } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1454,15 +2242,6 @@ impl AstNode for RecordLit { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl RecordLit { - pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } - pub fn record_field_list(&self) -> Option<RecordFieldList> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordFieldList { - pub(crate) syntax: SyntaxNode, -} impl AstNode for RecordFieldList { fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_LIST } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1474,18 +2253,6 @@ impl AstNode for RecordFieldList { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl RecordFieldList { - pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } - pub fn fields(&self) -> AstChildren<RecordField> { support::children(&self.syntax) } - pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) } - pub fn spread(&self) -> Option<Expr> { support::child(&self.syntax) } - pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordField { - pub(crate) syntax: SyntaxNode, -} impl AstNode for RecordField { fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1497,17 +2264,6 @@ impl AstNode for RecordField { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for RecordField {} -impl RecordField { - pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } - pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } - pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct OrPat { - pub(crate) syntax: SyntaxNode, -} impl AstNode for OrPat { fn can_cast(kind: SyntaxKind) -> bool { kind == OR_PAT } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1519,14 +2275,6 @@ impl AstNode for OrPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl OrPat { - pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ParenPat { - pub(crate) syntax: SyntaxNode, -} impl AstNode for ParenPat { fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_PAT } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1538,16 +2286,6 @@ impl AstNode for ParenPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ParenPat { - pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } - pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } - pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RefPat { - pub(crate) syntax: SyntaxNode, -} impl AstNode for RefPat { fn can_cast(kind: SyntaxKind) -> bool { kind == REF_PAT } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1559,16 +2297,6 @@ impl AstNode for RefPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl RefPat { - pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) } - pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } - pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct BoxPat { - pub(crate) syntax: SyntaxNode, -} impl AstNode for BoxPat { fn can_cast(kind: SyntaxKind) -> bool { kind == BOX_PAT } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1580,15 +2308,6 @@ impl AstNode for BoxPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl BoxPat { - pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) } - pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct BindPat { - pub(crate) syntax: SyntaxNode, -} impl AstNode for BindPat { fn can_cast(kind: SyntaxKind) -> bool { kind == BIND_PAT } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1600,19 +2319,6 @@ impl AstNode for BindPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for BindPat {} -impl ast::NameOwner for BindPat {} -impl BindPat { - pub fn ref_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ref]) } - pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } - pub fn at_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![@]) } - pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PlaceholderPat { - pub(crate) syntax: SyntaxNode, -} impl AstNode for PlaceholderPat { fn can_cast(kind: SyntaxKind) -> bool { kind == PLACEHOLDER_PAT } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1624,14 +2330,6 @@ impl AstNode for PlaceholderPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl PlaceholderPat { - pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct DotDotPat { - pub(crate) syntax: SyntaxNode, -} impl AstNode for DotDotPat { fn can_cast(kind: SyntaxKind) -> bool { kind == DOT_DOT_PAT } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1643,14 +2341,6 @@ impl AstNode for DotDotPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl DotDotPat { - pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PathPat { - pub(crate) syntax: SyntaxNode, -} impl AstNode for PathPat { fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_PAT } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1662,14 +2352,6 @@ impl AstNode for PathPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl PathPat { - pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SlicePat { - pub(crate) syntax: SyntaxNode, -} impl AstNode for SlicePat { fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_PAT } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1681,16 +2363,6 @@ impl AstNode for SlicePat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl SlicePat { - pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } - pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) } - pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RangePat { - pub(crate) syntax: SyntaxNode, -} impl AstNode for RangePat { fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_PAT } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1702,12 +2374,6 @@ impl AstNode for RangePat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl RangePat {} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LiteralPat { - pub(crate) syntax: SyntaxNode, -} impl AstNode for LiteralPat { fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL_PAT } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1719,14 +2385,6 @@ impl AstNode for LiteralPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl LiteralPat { - pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MacroPat { - pub(crate) syntax: SyntaxNode, -} impl AstNode for MacroPat { fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_PAT } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1738,14 +2396,6 @@ impl AstNode for MacroPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl MacroPat { - pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordPat { - pub(crate) syntax: SyntaxNode, -} impl AstNode for RecordPat { fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1757,17 +2407,6 @@ impl AstNode for RecordPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl RecordPat { - pub fn record_field_pat_list(&self) -> Option<RecordFieldPatList> { - support::child(&self.syntax) - } - pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordFieldPatList { - pub(crate) syntax: SyntaxNode, -} impl AstNode for RecordFieldPatList { fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_PAT_LIST } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1779,21 +2418,6 @@ impl AstNode for RecordFieldPatList { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl RecordFieldPatList { - pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } - pub fn pats(&self) -> AstChildren<RecordInnerPat> { support::children(&self.syntax) } - pub fn record_field_pats(&self) -> AstChildren<RecordFieldPat> { - support::children(&self.syntax) - } - pub fn bind_pats(&self) -> AstChildren<BindPat> { support::children(&self.syntax) } - pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) } - pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordFieldPat { - pub(crate) syntax: SyntaxNode, -} impl AstNode for RecordFieldPat { fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_PAT } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1805,17 +2429,6 @@ impl AstNode for RecordFieldPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for RecordFieldPat {} -impl RecordFieldPat { - pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } - pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } - pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TupleStructPat { - pub(crate) syntax: SyntaxNode, -} impl AstNode for TupleStructPat { fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_STRUCT_PAT } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1827,17 +2440,6 @@ impl AstNode for TupleStructPat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl TupleStructPat { - pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } - pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } - pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) } - pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TuplePat { - pub(crate) syntax: SyntaxNode, -} impl AstNode for TuplePat { fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_PAT } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1849,16 +2451,6 @@ impl AstNode for TuplePat { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl TuplePat { - pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } - pub fn args(&self) -> AstChildren<Pat> { support::children(&self.syntax) } - pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Visibility { - pub(crate) syntax: SyntaxNode, -} impl AstNode for Visibility { fn can_cast(kind: SyntaxKind) -> bool { kind == VISIBILITY } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1870,17 +2462,6 @@ impl AstNode for Visibility { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl Visibility { - pub fn pub_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![pub]) } - pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) } - pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) } - pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Name { - pub(crate) syntax: SyntaxNode, -} impl AstNode for Name { fn can_cast(kind: SyntaxKind) -> bool { kind == NAME } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1892,14 +2473,6 @@ impl AstNode for Name { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl Name { - pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct NameRef { - pub(crate) syntax: SyntaxNode, -} impl AstNode for NameRef { fn can_cast(kind: SyntaxKind) -> bool { kind == NAME_REF } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1911,12 +2484,6 @@ impl AstNode for NameRef { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl NameRef {} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MacroCall { - pub(crate) syntax: SyntaxNode, -} impl AstNode for MacroCall { fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_CALL } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1928,20 +2495,6 @@ impl AstNode for MacroCall { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::NameOwner for MacroCall {} -impl ast::AttrsOwner for MacroCall {} -impl ast::DocCommentsOwner for MacroCall {} -impl MacroCall { - pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } - pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) } - pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) } - pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Attr { - pub(crate) syntax: SyntaxNode, -} impl AstNode for Attr { fn can_cast(kind: SyntaxKind) -> bool { kind == ATTR } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1953,20 +2506,6 @@ impl AstNode for Attr { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl Attr { - pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) } - pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) } - pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } - pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } - pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } - pub fn input(&self) -> Option<AttrInput> { support::child(&self.syntax) } - pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TokenTree { - pub(crate) syntax: SyntaxNode, -} impl AstNode for TokenTree { fn can_cast(kind: SyntaxKind) -> bool { kind == TOKEN_TREE } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1978,12 +2517,6 @@ impl AstNode for TokenTree { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl TokenTree {} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TypeParamList { - pub(crate) syntax: SyntaxNode, -} impl AstNode for TypeParamList { fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_PARAM_LIST } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -1995,19 +2528,6 @@ impl AstNode for TypeParamList { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl TypeParamList { - pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) } - pub fn generic_params(&self) -> AstChildren<GenericParam> { support::children(&self.syntax) } - pub fn type_params(&self) -> AstChildren<TypeParam> { support::children(&self.syntax) } - pub fn lifetime_params(&self) -> AstChildren<LifetimeParam> { support::children(&self.syntax) } - pub fn const_params(&self) -> AstChildren<ConstParam> { support::children(&self.syntax) } - pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TypeParam { - pub(crate) syntax: SyntaxNode, -} impl AstNode for TypeParam { fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_PARAM } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2019,18 +2539,6 @@ impl AstNode for TypeParam { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::NameOwner for TypeParam {} -impl ast::AttrsOwner for TypeParam {} -impl ast::TypeBoundsOwner for TypeParam {} -impl TypeParam { - pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } - pub fn default_type(&self) -> Option<TypeRef> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ConstParam { - pub(crate) syntax: SyntaxNode, -} impl AstNode for ConstParam { fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_PARAM } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2042,18 +2550,6 @@ impl AstNode for ConstParam { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::NameOwner for ConstParam {} -impl ast::AttrsOwner for ConstParam {} -impl ast::TypeAscriptionOwner for ConstParam {} -impl ConstParam { - pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } - pub fn default_val(&self) -> Option<Expr> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LifetimeParam { - pub(crate) syntax: SyntaxNode, -} impl AstNode for LifetimeParam { fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_PARAM } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2065,17 +2561,6 @@ impl AstNode for LifetimeParam { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for LifetimeParam {} -impl LifetimeParam { - pub fn lifetime_token(&self) -> Option<SyntaxToken> { - support::token(&self.syntax, T![lifetime]) - } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TypeBound { - pub(crate) syntax: SyntaxNode, -} impl AstNode for TypeBound { fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2087,18 +2572,6 @@ impl AstNode for TypeBound { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl TypeBound { - pub fn lifetime_token(&self) -> Option<SyntaxToken> { - support::token(&self.syntax, T![lifetime]) - } - pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } - pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TypeBoundList { - pub(crate) syntax: SyntaxNode, -} impl AstNode for TypeBoundList { fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND_LIST } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2110,14 +2583,6 @@ impl AstNode for TypeBoundList { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl TypeBoundList { - pub fn bounds(&self) -> AstChildren<TypeBound> { support::children(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WherePred { - pub(crate) syntax: SyntaxNode, -} impl AstNode for WherePred { fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_PRED } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2129,18 +2594,6 @@ impl AstNode for WherePred { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::TypeBoundsOwner for WherePred {} -impl WherePred { - pub fn lifetime_token(&self) -> Option<SyntaxToken> { - support::token(&self.syntax, T![lifetime]) - } - pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WhereClause { - pub(crate) syntax: SyntaxNode, -} impl AstNode for WhereClause { fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_CLAUSE } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2152,15 +2605,6 @@ impl AstNode for WhereClause { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl WhereClause { - pub fn where_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![where]) } - pub fn predicates(&self) -> AstChildren<WherePred> { support::children(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Abi { - pub(crate) syntax: SyntaxNode, -} impl AstNode for Abi { fn can_cast(kind: SyntaxKind) -> bool { kind == ABI } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2172,12 +2616,6 @@ impl AstNode for Abi { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl Abi {} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ExprStmt { - pub(crate) syntax: SyntaxNode, -} impl AstNode for ExprStmt { fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_STMT } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2189,16 +2627,6 @@ impl AstNode for ExprStmt { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for ExprStmt {} -impl ExprStmt { - pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } - pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LetStmt { - pub(crate) syntax: SyntaxNode, -} impl AstNode for LetStmt { fn can_cast(kind: SyntaxKind) -> bool { kind == LET_STMT } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2210,20 +2638,6 @@ impl AstNode for LetStmt { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for LetStmt {} -impl ast::TypeAscriptionOwner for LetStmt {} -impl LetStmt { - pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) } - pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } - pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } - pub fn initializer(&self) -> Option<Expr> { support::child(&self.syntax) } - pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Condition { - pub(crate) syntax: SyntaxNode, -} impl AstNode for Condition { fn can_cast(kind: SyntaxKind) -> bool { kind == CONDITION } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2235,17 +2649,6 @@ impl AstNode for Condition { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl Condition { - pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) } - pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } - pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } - pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Block { - pub(crate) syntax: SyntaxNode, -} impl AstNode for Block { fn can_cast(kind: SyntaxKind) -> bool { kind == BLOCK } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2257,19 +2660,6 @@ impl AstNode for Block { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for Block {} -impl ast::ModuleItemOwner for Block {} -impl Block { - pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } - pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) } - pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } - pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ParamList { - pub(crate) syntax: SyntaxNode, -} impl AstNode for ParamList { fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM_LIST } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2281,17 +2671,6 @@ impl AstNode for ParamList { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ParamList { - pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } - pub fn self_param(&self) -> Option<SelfParam> { support::child(&self.syntax) } - pub fn params(&self) -> AstChildren<Param> { support::children(&self.syntax) } - pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SelfParam { - pub(crate) syntax: SyntaxNode, -} impl AstNode for SelfParam { fn can_cast(kind: SyntaxKind) -> bool { kind == SELF_PARAM } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2303,21 +2682,6 @@ impl AstNode for SelfParam { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::TypeAscriptionOwner for SelfParam {} -impl ast::AttrsOwner for SelfParam {} -impl SelfParam { - pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) } - pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } - pub fn lifetime_token(&self) -> Option<SyntaxToken> { - support::token(&self.syntax, T![lifetime]) - } - pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Param { - pub(crate) syntax: SyntaxNode, -} impl AstNode for Param { fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2329,17 +2693,6 @@ impl AstNode for Param { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::TypeAscriptionOwner for Param {} -impl ast::AttrsOwner for Param {} -impl Param { - pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } - pub fn dotdotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![...]) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct UseItem { - pub(crate) syntax: SyntaxNode, -} impl AstNode for UseItem { fn can_cast(kind: SyntaxKind) -> bool { kind == USE_ITEM } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2351,17 +2704,6 @@ impl AstNode for UseItem { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for UseItem {} -impl ast::VisibilityOwner for UseItem {} -impl UseItem { - pub fn use_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![use]) } - pub fn use_tree(&self) -> Option<UseTree> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct UseTree { - pub(crate) syntax: SyntaxNode, -} impl AstNode for UseTree { fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2373,17 +2715,6 @@ impl AstNode for UseTree { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl UseTree { - pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } - pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) } - pub fn use_tree_list(&self) -> Option<UseTreeList> { support::child(&self.syntax) } - pub fn alias(&self) -> Option<Alias> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Alias { - pub(crate) syntax: SyntaxNode, -} impl AstNode for Alias { fn can_cast(kind: SyntaxKind) -> bool { kind == ALIAS } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2395,15 +2726,6 @@ impl AstNode for Alias { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::NameOwner for Alias {} -impl Alias { - pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct UseTreeList { - pub(crate) syntax: SyntaxNode, -} impl AstNode for UseTreeList { fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE_LIST } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2415,16 +2737,6 @@ impl AstNode for UseTreeList { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl UseTreeList { - pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } - pub fn use_trees(&self) -> AstChildren<UseTree> { support::children(&self.syntax) } - pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ExternCrateItem { - pub(crate) syntax: SyntaxNode, -} impl AstNode for ExternCrateItem { fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_CRATE_ITEM } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2436,19 +2748,6 @@ impl AstNode for ExternCrateItem { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::AttrsOwner for ExternCrateItem {} -impl ast::VisibilityOwner for ExternCrateItem {} -impl ExternCrateItem { - pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) } - pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) } - pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } - pub fn alias(&self) -> Option<Alias> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ArgList { - pub(crate) syntax: SyntaxNode, -} impl AstNode for ArgList { fn can_cast(kind: SyntaxKind) -> bool { kind == ARG_LIST } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2460,16 +2759,6 @@ impl AstNode for ArgList { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ArgList { - pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } - pub fn args(&self) -> AstChildren<Expr> { support::children(&self.syntax) } - pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Path { - pub(crate) syntax: SyntaxNode, -} impl AstNode for Path { fn can_cast(kind: SyntaxKind) -> bool { kind == PATH } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2481,15 +2770,6 @@ impl AstNode for Path { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl Path { - pub fn segment(&self) -> Option<PathSegment> { support::child(&self.syntax) } - pub fn qualifier(&self) -> Option<Path> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PathSegment { - pub(crate) syntax: SyntaxNode, -} impl AstNode for PathSegment { fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_SEGMENT } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2501,21 +2781,6 @@ impl AstNode for PathSegment { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl PathSegment { - pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) } - pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) } - pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } - pub fn type_arg_list(&self) -> Option<TypeArgList> { support::child(&self.syntax) } - pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) } - pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } - pub fn path_type(&self) -> Option<PathType> { support::child(&self.syntax) } - pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TypeArgList { - pub(crate) syntax: SyntaxNode, -} impl AstNode for TypeArgList { fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ARG_LIST } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2527,21 +2792,6 @@ impl AstNode for TypeArgList { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl TypeArgList { - pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) } - pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) } - pub fn generic_args(&self) -> AstChildren<GenericArg> { support::children(&self.syntax) } - pub fn type_args(&self) -> AstChildren<TypeArg> { support::children(&self.syntax) } - pub fn lifetime_args(&self) -> AstChildren<LifetimeArg> { support::children(&self.syntax) } - pub fn assoc_type_args(&self) -> AstChildren<AssocTypeArg> { support::children(&self.syntax) } - pub fn const_args(&self) -> AstChildren<ConstArg> { support::children(&self.syntax) } - pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TypeArg { - pub(crate) syntax: SyntaxNode, -} impl AstNode for TypeArg { fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ARG } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2553,14 +2803,6 @@ impl AstNode for TypeArg { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl TypeArg { - pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct AssocTypeArg { - pub(crate) syntax: SyntaxNode, -} impl AstNode for AssocTypeArg { fn can_cast(kind: SyntaxKind) -> bool { kind == ASSOC_TYPE_ARG } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2572,17 +2814,6 @@ impl AstNode for AssocTypeArg { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::TypeBoundsOwner for AssocTypeArg {} -impl AssocTypeArg { - pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } - pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } - pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LifetimeArg { - pub(crate) syntax: SyntaxNode, -} impl AstNode for LifetimeArg { fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_ARG } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2594,16 +2825,6 @@ impl AstNode for LifetimeArg { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl LifetimeArg { - pub fn lifetime_token(&self) -> Option<SyntaxToken> { - support::token(&self.syntax, T![lifetime]) - } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ConstArg { - pub(crate) syntax: SyntaxNode, -} impl AstNode for ConstArg { fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_ARG } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2615,16 +2836,6 @@ impl AstNode for ConstArg { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ConstArg { - pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) } - pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } - pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MacroItems { - pub(crate) syntax: SyntaxNode, -} impl AstNode for MacroItems { fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_ITEMS } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2636,13 +2847,6 @@ impl AstNode for MacroItems { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::ModuleItemOwner for MacroItems {} -impl MacroItems {} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MacroStmts { - pub(crate) syntax: SyntaxNode, -} impl AstNode for MacroStmts { fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_STMTS } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2654,15 +2858,6 @@ impl AstNode for MacroStmts { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl MacroStmts { - pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) } - pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ExternItemList { - pub(crate) syntax: SyntaxNode, -} impl AstNode for ExternItemList { fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_ITEM_LIST } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2674,17 +2869,6 @@ impl AstNode for ExternItemList { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ast::ModuleItemOwner for ExternItemList {} -impl ExternItemList { - pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } - pub fn extern_items(&self) -> AstChildren<ExternItem> { support::children(&self.syntax) } - pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ExternBlock { - pub(crate) syntax: SyntaxNode, -} impl AstNode for ExternBlock { fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_BLOCK } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2696,15 +2880,6 @@ impl AstNode for ExternBlock { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl ExternBlock { - pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) } - pub fn extern_item_list(&self) -> Option<ExternItemList> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MetaItem { - pub(crate) syntax: SyntaxNode, -} impl AstNode for MetaItem { fn can_cast(kind: SyntaxKind) -> bool { kind == META_ITEM } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2716,17 +2891,6 @@ impl AstNode for MetaItem { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl MetaItem { - pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } - pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } - pub fn attr_input(&self) -> Option<AttrInput> { support::child(&self.syntax) } - pub fn nested_meta_items(&self) -> AstChildren<MetaItem> { support::children(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MacroDef { - pub(crate) syntax: SyntaxNode, -} impl AstNode for MacroDef { fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_DEF } fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2738,17 +2902,6 @@ impl AstNode for MacroDef { } fn syntax(&self) -> &SyntaxNode { &self.syntax } } -impl MacroDef { - pub fn name(&self) -> Option<Name> { support::child(&self.syntax) } - pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) } -} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum NominalDef { - StructDef(StructDef), - EnumDef(EnumDef), - UnionDef(UnionDef), -} impl From<StructDef> for NominalDef { fn from(node: StructDef) -> NominalDef { NominalDef::StructDef(node) } } @@ -2782,16 +2935,6 @@ impl AstNode for NominalDef { } } } -impl ast::NameOwner for NominalDef {} -impl ast::TypeParamsOwner for NominalDef {} -impl ast::AttrsOwner for NominalDef {} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum GenericParam { - LifetimeParam(LifetimeParam), - TypeParam(TypeParam), - ConstParam(ConstParam), -} impl From<LifetimeParam> for GenericParam { fn from(node: LifetimeParam) -> GenericParam { GenericParam::LifetimeParam(node) } } @@ -2825,14 +2968,6 @@ impl AstNode for GenericParam { } } } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum GenericArg { - LifetimeArg(LifetimeArg), - TypeArg(TypeArg), - ConstArg(ConstArg), - AssocTypeArg(AssocTypeArg), -} impl From<LifetimeArg> for GenericArg { fn from(node: LifetimeArg) -> GenericArg { GenericArg::LifetimeArg(node) } } @@ -2871,23 +3006,6 @@ impl AstNode for GenericArg { } } } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum TypeRef { - ParenType(ParenType), - TupleType(TupleType), - NeverType(NeverType), - PathType(PathType), - PointerType(PointerType), - ArrayType(ArrayType), - SliceType(SliceType), - ReferenceType(ReferenceType), - PlaceholderType(PlaceholderType), - FnPointerType(FnPointerType), - ForType(ForType), - ImplTraitType(ImplTraitType), - DynTraitType(DynTraitType), -} impl From<ParenType> for TypeRef { fn from(node: ParenType) -> TypeRef { TypeRef::ParenType(node) } } @@ -2973,24 +3091,6 @@ impl AstNode for TypeRef { } } } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum ModuleItem { - StructDef(StructDef), - UnionDef(UnionDef), - EnumDef(EnumDef), - FnDef(FnDef), - TraitDef(TraitDef), - TypeAliasDef(TypeAliasDef), - ImplDef(ImplDef), - UseItem(UseItem), - ExternCrateItem(ExternCrateItem), - ConstDef(ConstDef), - StaticDef(StaticDef), - Module(Module), - MacroCall(MacroCall), - ExternBlock(ExternBlock), -} impl From<StructDef> for ModuleItem { fn from(node: StructDef) -> ModuleItem { ModuleItem::StructDef(node) } } @@ -3081,16 +3181,6 @@ impl AstNode for ModuleItem { } } } -impl ast::NameOwner for ModuleItem {} -impl ast::AttrsOwner for ModuleItem {} -impl ast::VisibilityOwner for ModuleItem {} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum ImplItem { - FnDef(FnDef), - TypeAliasDef(TypeAliasDef), - ConstDef(ConstDef), -} impl From<FnDef> for ImplItem { fn from(node: FnDef) -> ImplItem { ImplItem::FnDef(node) } } @@ -3124,14 +3214,6 @@ impl AstNode for ImplItem { } } } -impl ast::NameOwner for ImplItem {} -impl ast::AttrsOwner for ImplItem {} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum ExternItem { - FnDef(FnDef), - StaticDef(StaticDef), -} impl From<FnDef> for ExternItem { fn from(node: FnDef) -> ExternItem { ExternItem::FnDef(node) } } @@ -3160,44 +3242,6 @@ impl AstNode for ExternItem { } } } -impl ast::NameOwner for ExternItem {} -impl ast::AttrsOwner for ExternItem {} -impl ast::VisibilityOwner for ExternItem {} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum Expr { - TupleExpr(TupleExpr), - ArrayExpr(ArrayExpr), - ParenExpr(ParenExpr), - PathExpr(PathExpr), - LambdaExpr(LambdaExpr), - IfExpr(IfExpr), - LoopExpr(LoopExpr), - ForExpr(ForExpr), - WhileExpr(WhileExpr), - ContinueExpr(ContinueExpr), - BreakExpr(BreakExpr), - Label(Label), - BlockExpr(BlockExpr), - ReturnExpr(ReturnExpr), - MatchExpr(MatchExpr), - RecordLit(RecordLit), - CallExpr(CallExpr), - IndexExpr(IndexExpr), - MethodCallExpr(MethodCallExpr), - FieldExpr(FieldExpr), - AwaitExpr(AwaitExpr), - TryExpr(TryExpr), - TryBlockExpr(TryBlockExpr), - CastExpr(CastExpr), - RefExpr(RefExpr), - PrefixExpr(PrefixExpr), - RangeExpr(RangeExpr), - BinExpr(BinExpr), - Literal(Literal), - MacroCall(MacroCall), - BoxExpr(BoxExpr), -} impl From<TupleExpr> for Expr { fn from(node: TupleExpr) -> Expr { Expr::TupleExpr(node) } } @@ -3376,26 +3420,6 @@ impl AstNode for Expr { } } } -impl ast::AttrsOwner for Expr {} - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum Pat { - OrPat(OrPat), - ParenPat(ParenPat), - RefPat(RefPat), - BoxPat(BoxPat), - BindPat(BindPat), - PlaceholderPat(PlaceholderPat), - DotDotPat(DotDotPat), - PathPat(PathPat), - RecordPat(RecordPat), - TupleStructPat(TupleStructPat), - TuplePat(TuplePat), - SlicePat(SlicePat), - RangePat(RangePat), - LiteralPat(LiteralPat), - MacroPat(MacroPat), -} impl From<OrPat> for Pat { fn from(node: OrPat) -> Pat { Pat::OrPat(node) } } @@ -3491,12 +3515,6 @@ impl AstNode for Pat { } } } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum RecordInnerPat { - RecordFieldPat(RecordFieldPat), - BindPat(BindPat), -} impl From<RecordFieldPat> for RecordInnerPat { fn from(node: RecordFieldPat) -> RecordInnerPat { RecordInnerPat::RecordFieldPat(node) } } @@ -3525,12 +3543,6 @@ impl AstNode for RecordInnerPat { } } } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum AttrInput { - Literal(Literal), - TokenTree(TokenTree), -} impl From<Literal> for AttrInput { fn from(node: Literal) -> AttrInput { AttrInput::Literal(node) } } @@ -3559,12 +3571,6 @@ impl AstNode for AttrInput { } } } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum Stmt { - LetStmt(LetStmt), - ExprStmt(ExprStmt), -} impl From<LetStmt> for Stmt { fn from(node: LetStmt) -> Stmt { Stmt::LetStmt(node) } } @@ -3593,12 +3599,6 @@ impl AstNode for Stmt { } } } - -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum FieldDefList { - RecordFieldDefList(RecordFieldDefList), - TupleFieldDefList(TupleFieldDefList), -} impl From<RecordFieldDefList> for FieldDefList { fn from(node: RecordFieldDefList) -> FieldDefList { FieldDefList::RecordFieldDefList(node) } } diff --git a/xtask/src/codegen/gen_syntax.rs b/xtask/src/codegen/gen_syntax.rs index ec1f6ad8a12..e9dc09552da 100644 --- a/xtask/src/codegen/gen_syntax.rs +++ b/xtask/src/codegen/gen_syntax.rs @@ -63,126 +63,138 @@ fn generate_tokens(grammar: AstSrc<'_>) -> Result<String> { } fn generate_nodes(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result<String> { - let nodes = grammar.nodes.iter().map(|node| { - let name = format_ident!("{}", node.name); - let kind = format_ident!("{}", to_upper_snake_case(&name.to_string())); - let traits = node.traits.iter().map(|trait_name| { - let trait_name = format_ident!("{}", trait_name); - quote!(impl ast::#trait_name for #name {}) - }); - - let methods = node.fields.iter().map(|field| { - let method_name = field.method_name(); - let ty = field.ty(); - - if field.is_many() { - quote! { - pub fn #method_name(&self) -> AstChildren<#ty> { - support::children(&self.syntax) - } - } - } else { - if let Some(token_kind) = field.token_kind() { + let (node_defs, node_boilerplate_impls): (Vec<_>, Vec<_>) = grammar + .nodes + .iter() + .map(|node| { + let name = format_ident!("{}", node.name); + let kind = format_ident!("{}", to_upper_snake_case(&name.to_string())); + let traits = node.traits.iter().map(|trait_name| { + let trait_name = format_ident!("{}", trait_name); + quote!(impl ast::#trait_name for #name {}) + }); + + let methods = node.fields.iter().map(|field| { + let method_name = field.method_name(); + let ty = field.ty(); + + if field.is_many() { quote! { - pub fn #method_name(&self) -> Option<#ty> { - support::token(&self.syntax, #token_kind) + pub fn #method_name(&self) -> AstChildren<#ty> { + support::children(&self.syntax) } } } else { - quote! { - pub fn #method_name(&self) -> Option<#ty> { - support::child(&self.syntax) + if let Some(token_kind) = field.token_kind() { + quote! { + pub fn #method_name(&self) -> Option<#ty> { + support::token(&self.syntax, #token_kind) + } + } + } else { + quote! { + pub fn #method_name(&self) -> Option<#ty> { + support::child(&self.syntax) + } } } } - } - }); - - quote! { - #[derive(Debug, Clone, PartialEq, Eq, Hash)] - pub struct #name { - pub(crate) syntax: SyntaxNode, - } - - impl AstNode for #name { - fn can_cast(kind: SyntaxKind) -> bool { - kind == #kind - } - fn cast(syntax: SyntaxNode) -> Option<Self> { - if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None } - } - fn syntax(&self) -> &SyntaxNode { &self.syntax } - } - - #(#traits)* - - impl #name { - #(#methods)* - } - } - }); + }); + ( + quote! { + #[derive(Debug, Clone, PartialEq, Eq, Hash)] + pub struct #name { + pub(crate) syntax: SyntaxNode, + } - let enums = grammar.enums.iter().map(|en| { - let variants = en.variants.iter().map(|var| format_ident!("{}", var)).collect::<Vec<_>>(); - let name = format_ident!("{}", en.name); - let kinds = variants - .iter() - .map(|name| format_ident!("{}", to_upper_snake_case(&name.to_string()))) - .collect::<Vec<_>>(); - let traits = en.traits.iter().map(|trait_name| { - let trait_name = format_ident!("{}", trait_name); - quote!(impl ast::#trait_name for #name {}) - }); + #(#traits)* - quote! { - #[derive(Debug, Clone, PartialEq, Eq, Hash)] - pub enum #name { - #(#variants(#variants),)* - } + impl #name { + #(#methods)* + } + }, + quote! { + impl AstNode for #name { + fn can_cast(kind: SyntaxKind) -> bool { + kind == #kind + } + fn cast(syntax: SyntaxNode) -> Option<Self> { + if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None } + } + fn syntax(&self) -> &SyntaxNode { &self.syntax } + } + }, + ) + }) + .unzip(); - #( - impl From<#variants> for #name { - fn from(node: #variants) -> #name { - #name::#variants(node) - } - } - )* + let (enum_defs, enum_boilerplate_impls): (Vec<_>, Vec<_>) = grammar + .enums + .iter() + .map(|en| { + let variants: Vec<_> = en.variants.iter().map(|var| format_ident!("{}", var)).collect(); + let name = format_ident!("{}", en.name); + let kinds: Vec<_> = variants + .iter() + .map(|name| format_ident!("{}", to_upper_snake_case(&name.to_string()))) + .collect(); + let traits = en.traits.iter().map(|trait_name| { + let trait_name = format_ident!("{}", trait_name); + quote!(impl ast::#trait_name for #name {}) + }); + + ( + quote! { + #[derive(Debug, Clone, PartialEq, Eq, Hash)] + pub enum #name { + #(#variants(#variants),)* + } - impl AstNode for #name { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - #(#kinds)|* => true, - _ => false, + #(#traits)* + }, + quote! { + #( + impl From<#variants> for #name { + fn from(node: #variants) -> #name { + #name::#variants(node) + } } - } - fn cast(syntax: SyntaxNode) -> Option<Self> { - let res = match syntax.kind() { - #( - #kinds => #name::#variants(#variants { syntax }), - )* - _ => return None, - }; - Some(res) - } - fn syntax(&self) -> &SyntaxNode { - match self { - #( - #name::#variants(it) => &it.syntax, - )* + )* + + impl AstNode for #name { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + #(#kinds)|* => true, + _ => false, + } + } + fn cast(syntax: SyntaxNode) -> Option<Self> { + let res = match syntax.kind() { + #( + #kinds => #name::#variants(#variants { syntax }), + )* + _ => return None, + }; + Some(res) + } + fn syntax(&self) -> &SyntaxNode { + match self { + #( + #name::#variants(it) => &it.syntax, + )* + } + } } - } - } + }, + ) + }) + .unzip(); - #(#traits)* - } - }); + let enum_names = grammar.enums.iter().map(|it| it.name); + let node_names = grammar.nodes.iter().map(|it| it.name); - let displays = grammar - .enums - .iter() - .map(|it| format_ident!("{}", it.name)) - .chain(grammar.nodes.iter().map(|it| format_ident!("{}", it.name))) - .map(|name| { + let display_impls = + enum_names.chain(node_names.clone()).map(|it| format_ident!("{}", it)).map(|name| { quote! { impl std::fmt::Display for #name { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { @@ -192,13 +204,13 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result<String> { } }); - let defined_nodes: HashSet<_> = grammar.nodes.iter().map(|node| node.name).collect(); + let defined_nodes: HashSet<_> = node_names.collect(); for node in kinds .nodes .iter() - .map(|kind| to_pascal_case(*kind)) - .filter(|name| !defined_nodes.contains(&**name)) + .map(|kind| to_pascal_case(kind)) + .filter(|name| !defined_nodes.contains(name.as_str())) { eprintln!("Warning: node {} not defined in ast source", node); } @@ -210,9 +222,11 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result<String> { T, }; - #(#nodes)* - #(#enums)* - #(#displays)* + #(#node_defs)* + #(#enum_defs)* + #(#node_boilerplate_impls)* + #(#enum_boilerplate_impls)* + #(#display_impls)* }; let ast = ast.to_string().replace("T ! [ ", "T![").replace(" ] )", "])"); @@ -380,20 +394,16 @@ fn to_pascal_case(s: &str) -> String { impl Field<'_> { fn is_many(&self) -> bool { - match self { - Field::Node { src: FieldSrc::Many(_), .. } => true, - _ => false, - } + matches!(self, Field::Node { src: FieldSrc::Many(_), .. }) } fn token_kind(&self) -> Option<proc_macro2::TokenStream> { - let res = match self { + match self { Field::Token(token) => { let token: proc_macro2::TokenStream = token.parse().unwrap(); - quote! { T![#token] } + Some(quote! { T![#token] }) } - _ => return None, - }; - Some(res) + _ => None, + } } fn method_name(&self) -> proc_macro2::Ident { match self { |