Unnamed repository; edit this file 'description' to name the repository.
Diffstat (limited to 'crates/syntax/src/ast/generated/nodes.rs')
| -rw-r--r-- | crates/syntax/src/ast/generated/nodes.rs | 1078 |
1 files changed, 1078 insertions, 0 deletions
diff --git a/crates/syntax/src/ast/generated/nodes.rs b/crates/syntax/src/ast/generated/nodes.rs index 3876ef71a0..69e2a9f9c1 100644 --- a/crates/syntax/src/ast/generated/nodes.rs +++ b/crates/syntax/src/ast/generated/nodes.rs @@ -2503,6 +2503,13 @@ pub struct AnyHasVisibility { impl ast::HasVisibility for AnyHasVisibility {} impl AstNode for Abi { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + ABI + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ABI } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2517,6 +2524,13 @@ impl AstNode for Abi { } impl AstNode for ArgList { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + ARG_LIST + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ARG_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2531,6 +2545,13 @@ impl AstNode for ArgList { } impl AstNode for ArrayExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + ARRAY_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2545,6 +2566,13 @@ impl AstNode for ArrayExpr { } impl AstNode for ArrayType { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + ARRAY_TYPE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2559,6 +2587,13 @@ impl AstNode for ArrayType { } impl AstNode for AsmClobberAbi { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + ASM_CLOBBER_ABI + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_CLOBBER_ABI } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2573,6 +2608,13 @@ impl AstNode for AsmClobberAbi { } impl AstNode for AsmConst { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + ASM_CONST + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_CONST } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2587,6 +2629,13 @@ impl AstNode for AsmConst { } impl AstNode for AsmDirSpec { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + ASM_DIR_SPEC + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_DIR_SPEC } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2601,6 +2650,13 @@ impl AstNode for AsmDirSpec { } impl AstNode for AsmExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + ASM_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2615,6 +2671,13 @@ impl AstNode for AsmExpr { } impl AstNode for AsmLabel { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + ASM_LABEL + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_LABEL } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2629,6 +2692,13 @@ impl AstNode for AsmLabel { } impl AstNode for AsmOperandExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + ASM_OPERAND_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_OPERAND_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2643,6 +2713,13 @@ impl AstNode for AsmOperandExpr { } impl AstNode for AsmOperandNamed { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + ASM_OPERAND_NAMED + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_OPERAND_NAMED } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2657,6 +2734,13 @@ impl AstNode for AsmOperandNamed { } impl AstNode for AsmOption { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + ASM_OPTION + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_OPTION } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2671,6 +2755,13 @@ impl AstNode for AsmOption { } impl AstNode for AsmOptions { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + ASM_OPTIONS + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_OPTIONS } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2685,6 +2776,13 @@ impl AstNode for AsmOptions { } impl AstNode for AsmRegOperand { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + ASM_REG_OPERAND + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_REG_OPERAND } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2699,6 +2797,13 @@ impl AstNode for AsmRegOperand { } impl AstNode for AsmRegSpec { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + ASM_REG_SPEC + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_REG_SPEC } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2713,6 +2818,13 @@ impl AstNode for AsmRegSpec { } impl AstNode for AsmSym { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + ASM_SYM + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_SYM } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2727,6 +2839,13 @@ impl AstNode for AsmSym { } impl AstNode for AssocItemList { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + ASSOC_ITEM_LIST + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ASSOC_ITEM_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2741,6 +2860,13 @@ impl AstNode for AssocItemList { } impl AstNode for AssocTypeArg { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + ASSOC_TYPE_ARG + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ASSOC_TYPE_ARG } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2755,6 +2881,13 @@ impl AstNode for AssocTypeArg { } impl AstNode for Attr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + ATTR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ATTR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2769,6 +2902,13 @@ impl AstNode for Attr { } impl AstNode for AwaitExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + AWAIT_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == AWAIT_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2783,6 +2923,13 @@ impl AstNode for AwaitExpr { } impl AstNode for BecomeExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + BECOME_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == BECOME_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2797,6 +2944,13 @@ impl AstNode for BecomeExpr { } impl AstNode for BinExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + BIN_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == BIN_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2811,6 +2965,13 @@ impl AstNode for BinExpr { } impl AstNode for BlockExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + BLOCK_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == BLOCK_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2825,6 +2986,13 @@ impl AstNode for BlockExpr { } impl AstNode for BoxPat { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + BOX_PAT + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == BOX_PAT } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2839,6 +3007,13 @@ impl AstNode for BoxPat { } impl AstNode for BreakExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + BREAK_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == BREAK_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2853,6 +3028,13 @@ impl AstNode for BreakExpr { } impl AstNode for CallExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + CALL_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CALL_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2867,6 +3049,13 @@ impl AstNode for CallExpr { } impl AstNode for CastExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + CAST_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CAST_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2881,6 +3070,13 @@ impl AstNode for CastExpr { } impl AstNode for ClosureBinder { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + CLOSURE_BINDER + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CLOSURE_BINDER } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2895,6 +3091,13 @@ impl AstNode for ClosureBinder { } impl AstNode for ClosureExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + CLOSURE_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CLOSURE_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2909,6 +3112,13 @@ impl AstNode for ClosureExpr { } impl AstNode for Const { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + CONST + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CONST } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2923,6 +3133,13 @@ impl AstNode for Const { } impl AstNode for ConstArg { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + CONST_ARG + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_ARG } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2937,6 +3154,13 @@ impl AstNode for ConstArg { } impl AstNode for ConstBlockPat { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + CONST_BLOCK_PAT + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_BLOCK_PAT } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2951,6 +3175,13 @@ impl AstNode for ConstBlockPat { } impl AstNode for ConstParam { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + CONST_PARAM + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_PARAM } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2965,6 +3196,13 @@ impl AstNode for ConstParam { } impl AstNode for ContinueExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + CONTINUE_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CONTINUE_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2979,6 +3217,13 @@ impl AstNode for ContinueExpr { } impl AstNode for DynTraitType { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + DYN_TRAIT_TYPE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == DYN_TRAIT_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -2993,6 +3238,13 @@ impl AstNode for DynTraitType { } impl AstNode for Enum { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + ENUM + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ENUM } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3007,6 +3259,13 @@ impl AstNode for Enum { } impl AstNode for ExprStmt { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + EXPR_STMT + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_STMT } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3021,6 +3280,13 @@ impl AstNode for ExprStmt { } impl AstNode for ExternBlock { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + EXTERN_BLOCK + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_BLOCK } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3035,6 +3301,13 @@ impl AstNode for ExternBlock { } impl AstNode for ExternCrate { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + EXTERN_CRATE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_CRATE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3049,6 +3322,13 @@ impl AstNode for ExternCrate { } impl AstNode for ExternItemList { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + EXTERN_ITEM_LIST + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_ITEM_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3063,6 +3343,13 @@ impl AstNode for ExternItemList { } impl AstNode for FieldExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + FIELD_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == FIELD_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3077,6 +3364,13 @@ impl AstNode for FieldExpr { } impl AstNode for Fn { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + FN + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == FN } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3091,6 +3385,13 @@ impl AstNode for Fn { } impl AstNode for FnPtrType { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + FN_PTR_TYPE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == FN_PTR_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3105,6 +3406,13 @@ impl AstNode for FnPtrType { } impl AstNode for ForExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + FOR_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3119,6 +3427,13 @@ impl AstNode for ForExpr { } impl AstNode for ForType { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + FOR_TYPE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3133,6 +3448,13 @@ impl AstNode for ForType { } impl AstNode for FormatArgsArg { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + FORMAT_ARGS_ARG + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == FORMAT_ARGS_ARG } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3147,6 +3469,13 @@ impl AstNode for FormatArgsArg { } impl AstNode for FormatArgsExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + FORMAT_ARGS_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == FORMAT_ARGS_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3161,6 +3490,13 @@ impl AstNode for FormatArgsExpr { } impl AstNode for GenericArgList { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + GENERIC_ARG_LIST + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == GENERIC_ARG_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3175,6 +3511,13 @@ impl AstNode for GenericArgList { } impl AstNode for GenericParamList { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + GENERIC_PARAM_LIST + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == GENERIC_PARAM_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3189,6 +3532,13 @@ impl AstNode for GenericParamList { } impl AstNode for IdentPat { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + IDENT_PAT + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == IDENT_PAT } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3203,6 +3553,13 @@ impl AstNode for IdentPat { } impl AstNode for IfExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + IF_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == IF_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3217,6 +3574,13 @@ impl AstNode for IfExpr { } impl AstNode for Impl { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + IMPL + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3231,6 +3595,13 @@ impl AstNode for Impl { } impl AstNode for ImplTraitType { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + IMPL_TRAIT_TYPE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL_TRAIT_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3245,6 +3616,13 @@ impl AstNode for ImplTraitType { } impl AstNode for IndexExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + INDEX_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == INDEX_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3259,6 +3637,13 @@ impl AstNode for IndexExpr { } impl AstNode for InferType { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + INFER_TYPE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == INFER_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3273,6 +3658,13 @@ impl AstNode for InferType { } impl AstNode for ItemList { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + ITEM_LIST + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ITEM_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3287,6 +3679,13 @@ impl AstNode for ItemList { } impl AstNode for Label { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + LABEL + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LABEL } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3301,6 +3700,13 @@ impl AstNode for Label { } impl AstNode for LetElse { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + LET_ELSE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LET_ELSE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3315,6 +3721,13 @@ impl AstNode for LetElse { } impl AstNode for LetExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + LET_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LET_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3329,6 +3742,13 @@ impl AstNode for LetExpr { } impl AstNode for LetStmt { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + LET_STMT + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LET_STMT } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3343,6 +3763,13 @@ impl AstNode for LetStmt { } impl AstNode for Lifetime { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + LIFETIME + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3357,6 +3784,13 @@ impl AstNode for Lifetime { } impl AstNode for LifetimeArg { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + LIFETIME_ARG + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_ARG } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3371,6 +3805,13 @@ impl AstNode for LifetimeArg { } impl AstNode for LifetimeParam { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + LIFETIME_PARAM + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_PARAM } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3385,6 +3826,13 @@ impl AstNode for LifetimeParam { } impl AstNode for Literal { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + LITERAL + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3399,6 +3847,13 @@ impl AstNode for Literal { } impl AstNode for LiteralPat { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + LITERAL_PAT + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL_PAT } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3413,6 +3868,13 @@ impl AstNode for LiteralPat { } impl AstNode for LoopExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + LOOP_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LOOP_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3427,6 +3889,13 @@ impl AstNode for LoopExpr { } impl AstNode for MacroCall { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + MACRO_CALL + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_CALL } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3441,6 +3910,13 @@ impl AstNode for MacroCall { } impl AstNode for MacroDef { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + MACRO_DEF + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_DEF } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3455,6 +3931,13 @@ impl AstNode for MacroDef { } impl AstNode for MacroExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + MACRO_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3469,6 +3952,13 @@ impl AstNode for MacroExpr { } impl AstNode for MacroItems { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + MACRO_ITEMS + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_ITEMS } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3483,6 +3973,13 @@ impl AstNode for MacroItems { } impl AstNode for MacroPat { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + MACRO_PAT + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_PAT } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3497,6 +3994,13 @@ impl AstNode for MacroPat { } impl AstNode for MacroRules { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + MACRO_RULES + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_RULES } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3511,6 +4015,13 @@ impl AstNode for MacroRules { } impl AstNode for MacroStmts { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + MACRO_STMTS + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_STMTS } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3525,6 +4036,13 @@ impl AstNode for MacroStmts { } impl AstNode for MacroType { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + MACRO_TYPE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3539,6 +4057,13 @@ impl AstNode for MacroType { } impl AstNode for MatchArm { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + MATCH_ARM + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3553,6 +4078,13 @@ impl AstNode for MatchArm { } impl AstNode for MatchArmList { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + MATCH_ARM_LIST + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3567,6 +4099,13 @@ impl AstNode for MatchArmList { } impl AstNode for MatchExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + MATCH_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3581,6 +4120,13 @@ impl AstNode for MatchExpr { } impl AstNode for MatchGuard { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + MATCH_GUARD + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_GUARD } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3595,6 +4141,13 @@ impl AstNode for MatchGuard { } impl AstNode for Meta { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + META + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == META } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3609,6 +4162,13 @@ impl AstNode for Meta { } impl AstNode for MethodCallExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + METHOD_CALL_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == METHOD_CALL_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3623,6 +4183,13 @@ impl AstNode for MethodCallExpr { } impl AstNode for Module { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + MODULE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MODULE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3637,6 +4204,13 @@ impl AstNode for Module { } impl AstNode for Name { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + NAME + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == NAME } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3651,6 +4225,13 @@ impl AstNode for Name { } impl AstNode for NameRef { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + NAME_REF + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == NAME_REF } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3665,6 +4246,13 @@ impl AstNode for NameRef { } impl AstNode for NeverType { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + NEVER_TYPE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == NEVER_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3679,6 +4267,13 @@ impl AstNode for NeverType { } impl AstNode for OffsetOfExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + OFFSET_OF_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == OFFSET_OF_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3693,6 +4288,13 @@ impl AstNode for OffsetOfExpr { } impl AstNode for OrPat { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + OR_PAT + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == OR_PAT } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3707,6 +4309,13 @@ impl AstNode for OrPat { } impl AstNode for Param { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + PARAM + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3721,6 +4330,13 @@ impl AstNode for Param { } impl AstNode for ParamList { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + PARAM_LIST + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3735,6 +4351,13 @@ impl AstNode for ParamList { } impl AstNode for ParenExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + PAREN_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3749,6 +4372,13 @@ impl AstNode for ParenExpr { } impl AstNode for ParenPat { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + PAREN_PAT + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_PAT } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3763,6 +4393,13 @@ impl AstNode for ParenPat { } impl AstNode for ParenType { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + PAREN_TYPE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3777,6 +4414,13 @@ impl AstNode for ParenType { } impl AstNode for ParenthesizedArgList { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + PARENTHESIZED_ARG_LIST + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PARENTHESIZED_ARG_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3791,6 +4435,13 @@ impl AstNode for ParenthesizedArgList { } impl AstNode for Path { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + PATH + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PATH } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3805,6 +4456,13 @@ impl AstNode for Path { } impl AstNode for PathExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + PATH_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3819,6 +4477,13 @@ impl AstNode for PathExpr { } impl AstNode for PathPat { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + PATH_PAT + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_PAT } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3833,6 +4498,13 @@ impl AstNode for PathPat { } impl AstNode for PathSegment { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + PATH_SEGMENT + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_SEGMENT } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3847,6 +4519,13 @@ impl AstNode for PathSegment { } impl AstNode for PathType { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + PATH_TYPE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3861,6 +4540,13 @@ impl AstNode for PathType { } impl AstNode for PrefixExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + PREFIX_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PREFIX_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3875,6 +4561,13 @@ impl AstNode for PrefixExpr { } impl AstNode for PtrType { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + PTR_TYPE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PTR_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3889,6 +4582,13 @@ impl AstNode for PtrType { } impl AstNode for RangeExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + RANGE_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3903,6 +4603,13 @@ impl AstNode for RangeExpr { } impl AstNode for RangePat { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + RANGE_PAT + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_PAT } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3917,6 +4624,13 @@ impl AstNode for RangePat { } impl AstNode for RecordExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + RECORD_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3931,6 +4645,13 @@ impl AstNode for RecordExpr { } impl AstNode for RecordExprField { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + RECORD_EXPR_FIELD + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR_FIELD } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3945,6 +4666,13 @@ impl AstNode for RecordExprField { } impl AstNode for RecordExprFieldList { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + RECORD_EXPR_FIELD_LIST + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR_FIELD_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3959,6 +4687,13 @@ impl AstNode for RecordExprFieldList { } impl AstNode for RecordField { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + RECORD_FIELD + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3973,6 +4708,13 @@ impl AstNode for RecordField { } impl AstNode for RecordFieldList { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + RECORD_FIELD_LIST + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -3987,6 +4729,13 @@ impl AstNode for RecordFieldList { } impl AstNode for RecordPat { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + RECORD_PAT + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4001,6 +4750,13 @@ impl AstNode for RecordPat { } impl AstNode for RecordPatField { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + RECORD_PAT_FIELD + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT_FIELD } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4015,6 +4771,13 @@ impl AstNode for RecordPatField { } impl AstNode for RecordPatFieldList { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + RECORD_PAT_FIELD_LIST + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT_FIELD_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4029,6 +4792,13 @@ impl AstNode for RecordPatFieldList { } impl AstNode for RefExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + REF_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == REF_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4043,6 +4813,13 @@ impl AstNode for RefExpr { } impl AstNode for RefPat { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + REF_PAT + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == REF_PAT } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4057,6 +4834,13 @@ impl AstNode for RefPat { } impl AstNode for RefType { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + REF_TYPE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == REF_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4071,6 +4855,13 @@ impl AstNode for RefType { } impl AstNode for Rename { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + RENAME + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RENAME } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4085,6 +4876,13 @@ impl AstNode for Rename { } impl AstNode for RestPat { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + REST_PAT + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == REST_PAT } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4099,6 +4897,13 @@ impl AstNode for RestPat { } impl AstNode for RetType { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + RET_TYPE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RET_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4113,6 +4918,13 @@ impl AstNode for RetType { } impl AstNode for ReturnExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + RETURN_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RETURN_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4127,6 +4939,13 @@ impl AstNode for ReturnExpr { } impl AstNode for ReturnTypeSyntax { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + RETURN_TYPE_SYNTAX + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RETURN_TYPE_SYNTAX } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4141,6 +4960,13 @@ impl AstNode for ReturnTypeSyntax { } impl AstNode for SelfParam { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + SELF_PARAM + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == SELF_PARAM } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4155,6 +4981,13 @@ impl AstNode for SelfParam { } impl AstNode for SlicePat { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + SLICE_PAT + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_PAT } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4169,6 +5002,13 @@ impl AstNode for SlicePat { } impl AstNode for SliceType { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + SLICE_TYPE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4183,6 +5023,13 @@ impl AstNode for SliceType { } impl AstNode for SourceFile { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + SOURCE_FILE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == SOURCE_FILE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4197,6 +5044,13 @@ impl AstNode for SourceFile { } impl AstNode for Static { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + STATIC + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == STATIC } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4211,6 +5065,13 @@ impl AstNode for Static { } impl AstNode for StmtList { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + STMT_LIST + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == STMT_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4225,6 +5086,13 @@ impl AstNode for StmtList { } impl AstNode for Struct { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + STRUCT + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == STRUCT } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4239,6 +5107,13 @@ impl AstNode for Struct { } impl AstNode for TokenTree { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + TOKEN_TREE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TOKEN_TREE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4253,6 +5128,13 @@ impl AstNode for TokenTree { } impl AstNode for Trait { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + TRAIT + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TRAIT } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4267,6 +5149,13 @@ impl AstNode for Trait { } impl AstNode for TraitAlias { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + TRAIT_ALIAS + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TRAIT_ALIAS } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4281,6 +5170,13 @@ impl AstNode for TraitAlias { } impl AstNode for TryExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + TRY_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TRY_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4295,6 +5191,13 @@ impl AstNode for TryExpr { } impl AstNode for TupleExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + TUPLE_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4309,6 +5212,13 @@ impl AstNode for TupleExpr { } impl AstNode for TupleField { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + TUPLE_FIELD + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4323,6 +5233,13 @@ impl AstNode for TupleField { } impl AstNode for TupleFieldList { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + TUPLE_FIELD_LIST + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4337,6 +5254,13 @@ impl AstNode for TupleFieldList { } impl AstNode for TuplePat { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + TUPLE_PAT + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_PAT } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4351,6 +5275,13 @@ impl AstNode for TuplePat { } impl AstNode for TupleStructPat { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + TUPLE_STRUCT_PAT + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_STRUCT_PAT } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4365,6 +5296,13 @@ impl AstNode for TupleStructPat { } impl AstNode for TupleType { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + TUPLE_TYPE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_TYPE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4379,6 +5317,13 @@ impl AstNode for TupleType { } impl AstNode for TypeAlias { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + TYPE_ALIAS + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ALIAS } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4393,6 +5338,13 @@ impl AstNode for TypeAlias { } impl AstNode for TypeArg { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + TYPE_ARG + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ARG } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4407,6 +5359,13 @@ impl AstNode for TypeArg { } impl AstNode for TypeBound { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + TYPE_BOUND + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4421,6 +5380,13 @@ impl AstNode for TypeBound { } impl AstNode for TypeBoundList { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + TYPE_BOUND_LIST + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4435,6 +5401,13 @@ impl AstNode for TypeBoundList { } impl AstNode for TypeParam { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + TYPE_PARAM + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_PARAM } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4449,6 +5422,13 @@ impl AstNode for TypeParam { } impl AstNode for UnderscoreExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + UNDERSCORE_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == UNDERSCORE_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4463,6 +5443,13 @@ impl AstNode for UnderscoreExpr { } impl AstNode for Union { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + UNION + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == UNION } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4477,6 +5464,13 @@ impl AstNode for Union { } impl AstNode for Use { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + USE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == USE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4491,6 +5485,13 @@ impl AstNode for Use { } impl AstNode for UseBoundGenericArgs { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + USE_BOUND_GENERIC_ARGS + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == USE_BOUND_GENERIC_ARGS } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4505,6 +5506,13 @@ impl AstNode for UseBoundGenericArgs { } impl AstNode for UseTree { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + USE_TREE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4519,6 +5527,13 @@ impl AstNode for UseTree { } impl AstNode for UseTreeList { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + USE_TREE_LIST + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4533,6 +5548,13 @@ impl AstNode for UseTreeList { } impl AstNode for Variant { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + VARIANT + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == VARIANT } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4547,6 +5569,13 @@ impl AstNode for Variant { } impl AstNode for VariantList { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + VARIANT_LIST + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == VARIANT_LIST } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4561,6 +5590,13 @@ impl AstNode for VariantList { } impl AstNode for Visibility { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + VISIBILITY + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == VISIBILITY } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4575,6 +5611,13 @@ impl AstNode for Visibility { } impl AstNode for WhereClause { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + WHERE_CLAUSE + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_CLAUSE } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4589,6 +5632,13 @@ impl AstNode for WhereClause { } impl AstNode for WherePred { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + WHERE_PRED + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_PRED } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4603,6 +5653,13 @@ impl AstNode for WherePred { } impl AstNode for WhileExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + WHILE_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == WHILE_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4617,6 +5674,13 @@ impl AstNode for WhileExpr { } impl AstNode for WildcardPat { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + WILDCARD_PAT + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == WILDCARD_PAT } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4631,6 +5695,13 @@ impl AstNode for WildcardPat { } impl AstNode for YeetExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + YEET_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == YEET_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { @@ -4645,6 +5716,13 @@ impl AstNode for YeetExpr { } impl AstNode for YieldExpr { #[inline] + fn kind() -> SyntaxKind + where + Self: Sized, + { + YIELD_EXPR + } + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == YIELD_EXPR } #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { |