diff options
26 files changed, 1115 insertions, 41 deletions
diff --git a/src/tools/rust-analyzer/crates/hir-def/src/body/lower.rs b/src/tools/rust-analyzer/crates/hir-def/src/body/lower.rs index faba9050fc4..be7068c807a 100644 --- a/src/tools/rust-analyzer/crates/hir-def/src/body/lower.rs +++ b/src/tools/rust-analyzer/crates/hir-def/src/body/lower.rs @@ -15,8 +15,8 @@ use span::AstIdMap; use stdx::never; use syntax::{ ast::{ - self, ArrayExprKind, AstChildren, BlockExpr, HasArgList, HasAttrs, HasLoopBody, HasName, - RangeItem, SlicePatComponents, + self, ArrayExprKind, AstChildren, BlockExpr, HasArgList, HasAttrs, HasGenericArgs, + HasLoopBody, HasName, RangeItem, SlicePatComponents, }, AstNode, AstPtr, AstToken as _, SyntaxNodePtr, }; diff --git a/src/tools/rust-analyzer/crates/hir-def/src/hir/type_ref.rs b/src/tools/rust-analyzer/crates/hir-def/src/hir/type_ref.rs index 741ae41c743..7272ed98ceb 100644 --- a/src/tools/rust-analyzer/crates/hir-def/src/hir/type_ref.rs +++ b/src/tools/rust-analyzer/crates/hir-def/src/hir/type_ref.rs @@ -10,7 +10,7 @@ use hir_expand::{ AstId, }; use intern::Interned; -use syntax::ast::{self, HasName, IsString}; +use syntax::ast::{self, HasGenericArgs, HasName, IsString}; use crate::{ builtin_type::{BuiltinInt, BuiltinType, BuiltinUint}, diff --git a/src/tools/rust-analyzer/crates/hir-def/src/path/lower.rs b/src/tools/rust-analyzer/crates/hir-def/src/path/lower.rs index a710c2dacaa..cee9e055459 100644 --- a/src/tools/rust-analyzer/crates/hir-def/src/path/lower.rs +++ b/src/tools/rust-analyzer/crates/hir-def/src/path/lower.rs @@ -9,7 +9,7 @@ use hir_expand::{ name::{name, AsName}, }; use intern::Interned; -use syntax::ast::{self, AstNode, HasTypeBounds}; +use syntax::ast::{self, AstNode, HasGenericArgs, HasTypeBounds}; use crate::{ path::{AssociatedTypeBinding, GenericArg, GenericArgs, ModPath, Path, PathKind}, diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_turbo_fish.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_turbo_fish.rs index 363aa142b25..327709b28a3 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_turbo_fish.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/add_turbo_fish.rs @@ -1,7 +1,7 @@ use either::Either; use ide_db::defs::{Definition, NameRefClass}; use syntax::{ - ast::{self, make, HasArgList}, + ast::{self, make, HasArgList, HasGenericArgs}, ted, AstNode, }; diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_from_to_tryfrom.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_from_to_tryfrom.rs index 5459bd334c8..67c72a93dad 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_from_to_tryfrom.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_from_to_tryfrom.rs @@ -1,7 +1,7 @@ use ide_db::{famous_defs::FamousDefs, traits::resolve_target_trait}; use itertools::Itertools; use syntax::{ - ast::{self, make, AstNode, HasName}, + ast::{self, make, AstNode, HasGenericArgs, HasName}, ted, }; diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_into_to_from.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_into_to_from.rs index 92da2678f97..5349e86cf38 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_into_to_from.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/convert_into_to_from.rs @@ -1,6 +1,6 @@ use hir::ImportPathConfig; use ide_db::{famous_defs::FamousDefs, helpers::mod_path_to_ast, traits::resolve_target_trait}; -use syntax::ast::{self, AstNode, HasName}; +use syntax::ast::{self, AstNode, HasGenericArgs, HasName}; use crate::{AssistContext, AssistId, AssistKind, Assists}; diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_type_alias.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_type_alias.rs index 3612eda7847..dcf16e89b2c 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_type_alias.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/extract_type_alias.rs @@ -1,7 +1,7 @@ use either::Either; use ide_db::syntax_helpers::node_ext::walk_ty; use syntax::{ - ast::{self, edit::IndentLevel, make, AstNode, HasGenericParams, HasName}, + ast::{self, edit::IndentLevel, make, AstNode, HasGenericArgs, HasGenericParams, HasName}, ted, }; diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_trait.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_trait.rs index 19521b8a4b7..78def51a4a9 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_trait.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_delegate_trait.rs @@ -17,8 +17,9 @@ use syntax::{ self, edit::{self, AstNodeEdit}, edit_in_place::AttrsOwnerEdit, - make, AssocItem, GenericArgList, GenericParamList, HasAttrs, HasGenericParams, HasName, - HasTypeBounds, HasVisibility as astHasVisibility, Path, WherePred, + make, AssocItem, GenericArgList, GenericParamList, HasAttrs, HasGenericArgs, + HasGenericParams, HasName, HasTypeBounds, HasVisibility as astHasVisibility, Path, + WherePred, }, ted::{self, Position}, AstNode, NodeOrToken, SmolStr, SyntaxKind, diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_documentation_template.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_documentation_template.rs index 38b24fd19ca..51dd4884547 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_documentation_template.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/generate_documentation_template.rs @@ -4,7 +4,7 @@ use itertools::Itertools; use stdx::{format_to, to_lower_snake_case}; use syntax::{ algo::skip_whitespace_token, - ast::{self, edit::IndentLevel, HasDocComments, HasName}, + ast::{self, edit::IndentLevel, HasDocComments, HasGenericArgs, HasName}, match_ast, AstNode, AstToken, }; diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/inline_call.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/inline_call.rs index 88fa6dc745e..8c9fe23bb0b 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/inline_call.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/inline_call.rs @@ -15,7 +15,9 @@ use ide_db::{ }; use itertools::{izip, Itertools}; use syntax::{ - ast::{self, edit::IndentLevel, edit_in_place::Indent, HasArgList, Pat, PathExpr}, + ast::{ + self, edit::IndentLevel, edit_in_place::Indent, HasArgList, HasGenericArgs, Pat, PathExpr, + }, ted, AstNode, NodeOrToken, SyntaxKind, }; diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/qualify_path.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/qualify_path.rs index ca6c7c58b70..4164a4c1024 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/qualify_path.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/qualify_path.rs @@ -6,6 +6,7 @@ use ide_db::{ helpers::mod_path_to_ast, imports::import_assets::{ImportCandidate, LocatedImport}, }; +use syntax::ast::HasGenericArgs; use syntax::{ ast, ast::{make, HasArgList}, diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_qualified_name_with_use.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_qualified_name_with_use.rs index f1467837dd0..b4e1a49aab5 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_qualified_name_with_use.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_qualified_name_with_use.rs @@ -4,7 +4,7 @@ use ide_db::{ imports::insert_use::{insert_use, ImportScope}, }; use syntax::{ - ast::{self, make}, + ast::{self, make, HasGenericArgs}, match_ast, ted, AstNode, SyntaxNode, }; diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_turbofish_with_explicit_type.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_turbofish_with_explicit_type.rs index 1794c887439..3a6391cd380 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_turbofish_with_explicit_type.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/replace_turbofish_with_explicit_type.rs @@ -1,7 +1,6 @@ use hir::HirDisplay; use syntax::{ - ast::{Expr, GenericArg, GenericArgList}, - ast::{LetStmt, Type::InferType}, + ast::{Expr, GenericArg, GenericArgList, HasGenericArgs, LetStmt, Type::InferType}, AstNode, TextRange, }; diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/toggle_async_sugar.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/toggle_async_sugar.rs index f79f87db9a6..31d18a60138 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/toggle_async_sugar.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/toggle_async_sugar.rs @@ -4,7 +4,7 @@ use ide_db::{ famous_defs::FamousDefs, }; use syntax::{ - ast::{self, HasVisibility}, + ast::{self, HasGenericArgs, HasVisibility}, AstNode, NodeOrToken, SyntaxKind, SyntaxNode, SyntaxToken, TextRange, }; diff --git a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unwrap_result_return_type.rs b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unwrap_result_return_type.rs index 8a9e669630b..a1987247cb6 100644 --- a/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unwrap_result_return_type.rs +++ b/src/tools/rust-analyzer/crates/ide-assists/src/handlers/unwrap_result_return_type.rs @@ -4,7 +4,7 @@ use ide_db::{ }; use itertools::Itertools; use syntax::{ - ast::{self, Expr}, + ast::{self, Expr, HasGenericArgs}, match_ast, AstNode, NodeOrToken, SyntaxKind, TextRange, }; diff --git a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs index 80dcfd2f524..a14fe24fa75 100644 --- a/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs +++ b/src/tools/rust-analyzer/crates/ide-completion/src/context/analysis.rs @@ -6,7 +6,10 @@ use ide_db::{active_parameter::ActiveParameter, RootDatabase}; use itertools::Either; use syntax::{ algo::{ancestors_at_offset, find_node_at_offset, non_trivia_sibling}, - ast::{self, AttrKind, HasArgList, HasGenericParams, HasLoopBody, HasName, NameOrNameRef}, + ast::{ + self, AttrKind, HasArgList, HasGenericArgs, HasGenericParams, HasLoopBody, HasName, + NameOrNameRef, + }, match_ast, AstNode, AstToken, Direction, NodeOrToken, SyntaxElement, SyntaxKind, SyntaxNode, SyntaxToken, TextRange, TextSize, T, }; diff --git a/src/tools/rust-analyzer/crates/ide-db/src/path_transform.rs b/src/tools/rust-analyzer/crates/ide-db/src/path_transform.rs index 90c691ed6c9..e21d54ccd0e 100644 --- a/src/tools/rust-analyzer/crates/ide-db/src/path_transform.rs +++ b/src/tools/rust-analyzer/crates/ide-db/src/path_transform.rs @@ -6,7 +6,7 @@ use hir::{AsAssocItem, HirDisplay, ImportPathConfig, ModuleDef, SemanticsScope}; use itertools::Itertools; use rustc_hash::FxHashMap; use syntax::{ - ast::{self, make, AstNode}, + ast::{self, make, AstNode, HasGenericArgs}, ted, SyntaxNode, }; diff --git a/src/tools/rust-analyzer/crates/ide-ssr/src/matching.rs b/src/tools/rust-analyzer/crates/ide-ssr/src/matching.rs index 0d22bc94c61..7c357b3c217 100644 --- a/src/tools/rust-analyzer/crates/ide-ssr/src/matching.rs +++ b/src/tools/rust-analyzer/crates/ide-ssr/src/matching.rs @@ -10,7 +10,7 @@ use hir::{ImportPathConfig, Semantics}; use ide_db::{base_db::FileRange, FxHashMap}; use std::{cell::Cell, iter::Peekable}; use syntax::{ - ast::{self, AstNode, AstToken}, + ast::{self, AstNode, AstToken, HasGenericArgs}, SmolStr, SyntaxElement, SyntaxElementChildren, SyntaxKind, SyntaxNode, SyntaxToken, }; diff --git a/src/tools/rust-analyzer/crates/ide-ssr/src/resolving.rs b/src/tools/rust-analyzer/crates/ide-ssr/src/resolving.rs index 4731f14f4e6..d3c1af1f31e 100644 --- a/src/tools/rust-analyzer/crates/ide-ssr/src/resolving.rs +++ b/src/tools/rust-analyzer/crates/ide-ssr/src/resolving.rs @@ -3,7 +3,10 @@ use hir::AsAssocItem; use ide_db::{base_db::FilePosition, FxHashMap}; use parsing::Placeholder; -use syntax::{ast, SmolStr, SyntaxKind, SyntaxNode, SyntaxToken}; +use syntax::{ + ast::{self, HasGenericArgs}, + SmolStr, SyntaxKind, SyntaxNode, SyntaxToken, +}; use crate::{errors::error, parsing, SsrError}; diff --git a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bind_pat.rs b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bind_pat.rs index 3311bb48ad6..1118f11d99d 100644 --- a/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bind_pat.rs +++ b/src/tools/rust-analyzer/crates/ide/src/inlay_hints/bind_pat.rs @@ -8,7 +8,7 @@ use ide_db::{base_db::FileId, famous_defs::FamousDefs, RootDatabase}; use itertools::Itertools; use syntax::{ - ast::{self, AstNode, HasName}, + ast::{self, AstNode, HasGenericArgs, HasName}, match_ast, }; diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast.rs b/src/tools/rust-analyzer/crates/syntax/src/ast.rs index 168ca9f1328..3282bd6eff2 100644 --- a/src/tools/rust-analyzer/crates/syntax/src/ast.rs +++ b/src/tools/rust-analyzer/crates/syntax/src/ast.rs @@ -31,8 +31,8 @@ pub use self::{ operators::{ArithOp, BinaryOp, CmpOp, LogicOp, Ordering, RangeOp, UnaryOp}, token_ext::{CommentKind, CommentPlacement, CommentShape, IsString, QuoteOffsets, Radix}, traits::{ - AttrDocCommentIter, DocCommentIter, HasArgList, HasAttrs, HasDocComments, HasGenericParams, - HasLoopBody, HasModuleItem, HasName, HasTypeBounds, HasVisibility, + AttrDocCommentIter, DocCommentIter, HasArgList, HasAttrs, HasDocComments, HasGenericArgs, + HasGenericParams, HasLoopBody, HasModuleItem, HasName, HasTypeBounds, HasVisibility, }, }; @@ -149,14 +149,17 @@ pub trait RangeItem { mod support { use super::{AstChildren, AstNode, SyntaxKind, SyntaxNode, SyntaxToken}; + #[inline] pub(super) fn child<N: AstNode>(parent: &SyntaxNode) -> Option<N> { parent.children().find_map(N::cast) } + #[inline] pub(super) fn children<N: AstNode>(parent: &SyntaxNode) -> AstChildren<N> { AstChildren::new(parent) } + #[inline] pub(super) fn token(parent: &SyntaxNode, kind: SyntaxKind) -> Option<SyntaxToken> { parent.children_with_tokens().filter_map(|it| it.into_token()).find(|it| it.kind() == kind) } diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs index 2445e4f1a32..f1286e7aa21 100644 --- a/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs +++ b/src/tools/rust-analyzer/crates/syntax/src/ast/edit_in_place.rs @@ -6,7 +6,7 @@ use parser::{SyntaxKind, T}; use crate::{ algo::{self, neighbor}, - ast::{self, edit::IndentLevel, make, HasGenericParams}, + ast::{self, edit::IndentLevel, make, HasGenericArgs, HasGenericParams}, ted::{self, Position}, AstNode, AstToken, Direction, SyntaxElement, SyntaxKind::{ATTR, COMMENT, WHITESPACE}, diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/generated/nodes.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/generated/nodes.rs index ce189acd68e..0373e7c5529 100644 --- a/src/tools/rust-analyzer/crates/syntax/src/ast/generated/nodes.rs +++ b/src/tools/rust-analyzer/crates/syntax/src/ast/generated/nodes.rs @@ -12,6 +12,7 @@ pub struct Abi { pub(crate) syntax: SyntaxNode, } impl Abi { + #[inline] pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) } } @@ -20,7 +21,9 @@ pub struct ArgList { pub(crate) syntax: SyntaxNode, } impl ArgList { + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } } @@ -30,10 +33,15 @@ pub struct ArrayExpr { } impl ast::HasAttrs for ArrayExpr {} impl ArrayExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) } + #[inline] pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } + #[inline] pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } } @@ -42,10 +50,15 @@ pub struct ArrayType { pub(crate) syntax: SyntaxNode, } impl ArrayType { + #[inline] pub fn const_arg(&self) -> Option<ConstArg> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } + #[inline] pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } } @@ -55,11 +68,17 @@ pub struct AsmExpr { } impl ast::HasAttrs for AsmExpr {} impl AsmExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } + #[inline] pub fn asm_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![asm]) } + #[inline] pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) } } @@ -69,8 +88,11 @@ pub struct AssocItemList { } impl ast::HasAttrs for AssocItemList {} impl AssocItemList { + #[inline] pub fn assoc_items(&self) -> AstChildren<AssocItem> { support::children(&self.syntax) } + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } } @@ -78,14 +100,20 @@ impl AssocItemList { pub struct AssocTypeArg { pub(crate) syntax: SyntaxNode, } +impl ast::HasGenericArgs for AssocTypeArg {} impl ast::HasTypeBounds for AssocTypeArg {} impl AssocTypeArg { + #[inline] pub fn const_arg(&self) -> Option<ConstArg> { support::child(&self.syntax) } - pub fn generic_arg_list(&self) -> Option<GenericArgList> { support::child(&self.syntax) } + #[inline] pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } + #[inline] pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) } + #[inline] pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } } @@ -94,10 +122,15 @@ pub struct Attr { pub(crate) syntax: SyntaxNode, } impl Attr { + #[inline] pub fn meta(&self) -> Option<Meta> { support::child(&self.syntax) } + #[inline] pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) } + #[inline] pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) } + #[inline] pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } + #[inline] pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } } @@ -107,8 +140,11 @@ pub struct AwaitExpr { } impl ast::HasAttrs for AwaitExpr {} impl AwaitExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) } + #[inline] pub fn await_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![await]) } } @@ -118,7 +154,9 @@ pub struct BecomeExpr { } impl ast::HasAttrs for BecomeExpr {} impl BecomeExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn become_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![become]) } } @@ -135,11 +173,17 @@ pub struct BlockExpr { } impl ast::HasAttrs for BlockExpr {} impl BlockExpr { + #[inline] pub fn label(&self) -> Option<Label> { support::child(&self.syntax) } + #[inline] pub fn stmt_list(&self) -> Option<StmtList> { support::child(&self.syntax) } + #[inline] pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) } + #[inline] pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } + #[inline] pub fn try_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![try]) } + #[inline] pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) } } @@ -148,7 +192,9 @@ pub struct BoxPat { pub(crate) syntax: SyntaxNode, } impl BoxPat { + #[inline] pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + #[inline] pub fn box_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![box]) } } @@ -158,8 +204,11 @@ pub struct BreakExpr { } impl ast::HasAttrs for BreakExpr {} impl BreakExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) } + #[inline] pub fn break_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![break]) } } @@ -170,6 +219,7 @@ pub struct CallExpr { impl ast::HasArgList for CallExpr {} impl ast::HasAttrs for CallExpr {} impl CallExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } } @@ -179,8 +229,11 @@ pub struct CastExpr { } impl ast::HasAttrs for CastExpr {} impl CastExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) } } @@ -190,13 +243,21 @@ pub struct ClosureExpr { } impl ast::HasAttrs for ClosureExpr {} impl ClosureExpr { + #[inline] pub fn generic_param_list(&self) -> Option<GenericParamList> { support::child(&self.syntax) } + #[inline] pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) } + #[inline] pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } + #[inline] pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) } + #[inline] pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } + #[inline] pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) } + #[inline] pub fn move_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![move]) } + #[inline] pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) } } @@ -209,12 +270,19 @@ impl ast::HasDocComments for Const {} impl ast::HasName for Const {} impl ast::HasVisibility for Const {} impl Const { + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + #[inline] pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) } + #[inline] pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } + #[inline] pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) } } @@ -223,6 +291,7 @@ pub struct ConstArg { pub(crate) syntax: SyntaxNode, } impl ConstArg { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } } @@ -231,7 +300,9 @@ pub struct ConstBlockPat { pub(crate) syntax: SyntaxNode, } impl ConstBlockPat { + #[inline] pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) } + #[inline] pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } } @@ -242,10 +313,15 @@ pub struct ConstParam { impl ast::HasAttrs for ConstParam {} impl ast::HasName for ConstParam {} impl ConstParam { + #[inline] pub fn default_val(&self) -> Option<ConstArg> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + #[inline] pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } } @@ -255,7 +331,9 @@ pub struct ContinueExpr { } impl ast::HasAttrs for ContinueExpr {} impl ContinueExpr { + #[inline] pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) } + #[inline] pub fn continue_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![continue]) } @@ -266,7 +344,9 @@ pub struct DynTraitType { pub(crate) syntax: SyntaxNode, } impl DynTraitType { + #[inline] pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) } + #[inline] pub fn dyn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![dyn]) } } @@ -280,7 +360,9 @@ impl ast::HasGenericParams for Enum {} impl ast::HasName for Enum {} impl ast::HasVisibility for Enum {} impl Enum { + #[inline] pub fn variant_list(&self) -> Option<VariantList> { support::child(&self.syntax) } + #[inline] pub fn enum_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![enum]) } } @@ -289,7 +371,9 @@ pub struct ExprStmt { pub(crate) syntax: SyntaxNode, } impl ExprStmt { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } } @@ -300,8 +384,11 @@ pub struct ExternBlock { impl ast::HasAttrs for ExternBlock {} impl ast::HasDocComments for ExternBlock {} impl ExternBlock { + #[inline] pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) } + #[inline] pub fn extern_item_list(&self) -> Option<ExternItemList> { support::child(&self.syntax) } + #[inline] pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) } } @@ -313,10 +400,15 @@ impl ast::HasAttrs for ExternCrate {} impl ast::HasDocComments for ExternCrate {} impl ast::HasVisibility for ExternCrate {} impl ExternCrate { + #[inline] pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } + #[inline] pub fn rename(&self) -> Option<Rename> { support::child(&self.syntax) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } + #[inline] pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) } + #[inline] pub fn extern_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![extern]) } } @@ -326,8 +418,11 @@ pub struct ExternItemList { } impl ast::HasAttrs for ExternItemList {} impl ExternItemList { + #[inline] pub fn extern_items(&self) -> AstChildren<ExternItem> { support::children(&self.syntax) } + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } } @@ -337,8 +432,11 @@ pub struct FieldExpr { } impl ast::HasAttrs for FieldExpr {} impl FieldExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } + #[inline] pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) } } @@ -352,14 +450,23 @@ impl ast::HasGenericParams for Fn {} impl ast::HasName for Fn {} impl ast::HasVisibility for Fn {} impl Fn { + #[inline] pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) } + #[inline] pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) } + #[inline] pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } + #[inline] pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) } + #[inline] pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } + #[inline] pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) } + #[inline] pub fn fn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![fn]) } + #[inline] pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) } } @@ -368,12 +475,19 @@ pub struct FnPtrType { pub(crate) syntax: SyntaxNode, } impl FnPtrType { + #[inline] pub fn abi(&self) -> Option<Abi> { support::child(&self.syntax) } + #[inline] pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) } + #[inline] pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } + #[inline] pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) } + #[inline] pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } + #[inline] pub fn fn_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![fn]) } + #[inline] pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) } } @@ -383,8 +497,11 @@ pub struct ForExpr { } impl ast::HasAttrs for ForExpr {} impl ForExpr { + #[inline] pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + #[inline] pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) } + #[inline] pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) } } @@ -393,8 +510,11 @@ pub struct ForType { pub(crate) syntax: SyntaxNode, } impl ForType { + #[inline] pub fn generic_param_list(&self) -> Option<GenericParamList> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) } } @@ -404,7 +524,9 @@ pub struct FormatArgsArg { } impl ast::HasName for FormatArgsArg {} impl FormatArgsArg { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } } @@ -414,12 +536,19 @@ pub struct FormatArgsExpr { } impl ast::HasAttrs for FormatArgsExpr {} impl FormatArgsExpr { + #[inline] pub fn template(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } + #[inline] pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) } + #[inline] pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) } + #[inline] pub fn format_args_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![format_args]) } @@ -430,9 +559,13 @@ pub struct GenericArgList { pub(crate) syntax: SyntaxNode, } impl GenericArgList { + #[inline] pub fn generic_args(&self) -> AstChildren<GenericArg> { support::children(&self.syntax) } + #[inline] pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) } + #[inline] pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) } + #[inline] pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) } } @@ -441,8 +574,11 @@ pub struct GenericParamList { pub(crate) syntax: SyntaxNode, } impl GenericParamList { + #[inline] pub fn generic_params(&self) -> AstChildren<GenericParam> { support::children(&self.syntax) } + #[inline] pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) } + #[inline] pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) } } @@ -453,9 +589,13 @@ pub struct IdentPat { impl ast::HasAttrs for IdentPat {} impl ast::HasName for IdentPat {} impl IdentPat { + #[inline] pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + #[inline] pub fn at_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![@]) } + #[inline] pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } + #[inline] pub fn ref_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ref]) } } @@ -465,7 +605,9 @@ pub struct IfExpr { } impl ast::HasAttrs for IfExpr {} impl IfExpr { + #[inline] pub fn else_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![else]) } + #[inline] pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) } } @@ -478,12 +620,19 @@ impl ast::HasDocComments for Impl {} impl ast::HasGenericParams for Impl {} impl ast::HasVisibility for Impl {} impl Impl { + #[inline] pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) } + #[inline] pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) } + #[inline] pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } + #[inline] pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) } + #[inline] pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) } + #[inline] pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) } + #[inline] pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) } } @@ -492,7 +641,9 @@ pub struct ImplTraitType { pub(crate) syntax: SyntaxNode, } impl ImplTraitType { + #[inline] pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) } + #[inline] pub fn impl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![impl]) } } @@ -502,7 +653,9 @@ pub struct IndexExpr { } impl ast::HasAttrs for IndexExpr {} impl IndexExpr { + #[inline] pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } + #[inline] pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } } @@ -511,6 +664,7 @@ pub struct InferType { pub(crate) syntax: SyntaxNode, } impl InferType { + #[inline] pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) } } @@ -521,7 +675,9 @@ pub struct ItemList { impl ast::HasAttrs for ItemList {} impl ast::HasModuleItem for ItemList {} impl ItemList { + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } } @@ -530,7 +686,9 @@ pub struct Label { pub(crate) syntax: SyntaxNode, } impl Label { + #[inline] pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) } + #[inline] pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } } @@ -539,7 +697,9 @@ pub struct LetElse { pub(crate) syntax: SyntaxNode, } impl LetElse { + #[inline] pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) } + #[inline] pub fn else_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![else]) } } @@ -549,9 +709,13 @@ pub struct LetExpr { } impl ast::HasAttrs for LetExpr {} impl LetExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + #[inline] pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) } } @@ -561,13 +725,21 @@ pub struct LetStmt { } impl ast::HasAttrs for LetStmt {} impl LetStmt { + #[inline] pub fn initializer(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn let_else(&self) -> Option<LetElse> { support::child(&self.syntax) } + #[inline] pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + #[inline] pub fn let_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![let]) } } @@ -576,6 +748,7 @@ pub struct Lifetime { pub(crate) syntax: SyntaxNode, } impl Lifetime { + #[inline] pub fn lifetime_ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![lifetime_ident]) } @@ -586,6 +759,7 @@ pub struct LifetimeArg { pub(crate) syntax: SyntaxNode, } impl LifetimeArg { + #[inline] pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) } } @@ -596,6 +770,7 @@ pub struct LifetimeParam { impl ast::HasAttrs for LifetimeParam {} impl ast::HasTypeBounds for LifetimeParam {} impl LifetimeParam { + #[inline] pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) } } @@ -611,7 +786,9 @@ pub struct LiteralPat { pub(crate) syntax: SyntaxNode, } impl LiteralPat { + #[inline] pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) } + #[inline] pub fn minus_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![-]) } } @@ -622,6 +799,7 @@ pub struct LoopExpr { impl ast::HasAttrs for LoopExpr {} impl ast::HasLoopBody for LoopExpr {} impl LoopExpr { + #[inline] pub fn loop_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![loop]) } } @@ -632,9 +810,13 @@ pub struct MacroCall { impl ast::HasAttrs for MacroCall {} impl ast::HasDocComments for MacroCall {} impl MacroCall { + #[inline] pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } + #[inline] pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) } + #[inline] pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } } @@ -647,6 +829,7 @@ impl ast::HasDocComments for MacroDef {} impl ast::HasName for MacroDef {} impl ast::HasVisibility for MacroDef {} impl MacroDef { + #[inline] pub fn macro_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![macro]) } } @@ -655,12 +838,19 @@ pub struct MacroEagerInput { pub(crate) syntax: SyntaxNode, } impl MacroEagerInput { + #[inline] pub fn exprs(&self) -> AstChildren<Expr> { support::children(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } + #[inline] pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } + #[inline] pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } } @@ -669,6 +859,7 @@ pub struct MacroExpr { pub(crate) syntax: SyntaxNode, } impl MacroExpr { + #[inline] pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) } } @@ -684,6 +875,7 @@ pub struct MacroPat { pub(crate) syntax: SyntaxNode, } impl MacroPat { + #[inline] pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) } } @@ -696,8 +888,11 @@ impl ast::HasDocComments for MacroRules {} impl ast::HasName for MacroRules {} impl ast::HasVisibility for MacroRules {} impl MacroRules { + #[inline] pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) } + #[inline] pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) } + #[inline] pub fn macro_rules_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![macro_rules]) } @@ -708,7 +903,9 @@ pub struct MacroStmts { pub(crate) syntax: SyntaxNode, } impl MacroStmts { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) } } @@ -717,6 +914,7 @@ pub struct MacroType { pub(crate) syntax: SyntaxNode, } impl MacroType { + #[inline] pub fn macro_call(&self) -> Option<MacroCall> { support::child(&self.syntax) } } @@ -726,10 +924,15 @@ pub struct MatchArm { } impl ast::HasAttrs for MatchArm {} impl MatchArm { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn guard(&self) -> Option<MatchGuard> { support::child(&self.syntax) } + #[inline] pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + #[inline] pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) } + #[inline] pub fn fat_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=>]) } } @@ -739,8 +942,11 @@ pub struct MatchArmList { } impl ast::HasAttrs for MatchArmList {} impl MatchArmList { + #[inline] pub fn arms(&self) -> AstChildren<MatchArm> { support::children(&self.syntax) } + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } } @@ -750,8 +956,11 @@ pub struct MatchExpr { } impl ast::HasAttrs for MatchExpr {} impl MatchExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn match_arm_list(&self) -> Option<MatchArmList> { support::child(&self.syntax) } + #[inline] pub fn match_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![match]) } } @@ -760,6 +969,7 @@ pub struct MatchGuard { pub(crate) syntax: SyntaxNode, } impl MatchGuard { + #[inline] pub fn if_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![if]) } } @@ -768,12 +978,19 @@ pub struct Meta { pub(crate) syntax: SyntaxNode, } impl Meta { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } + #[inline] pub fn token_tree(&self) -> Option<TokenTree> { support::child(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + #[inline] pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) } } @@ -783,10 +1000,13 @@ pub struct MethodCallExpr { } impl ast::HasArgList for MethodCallExpr {} impl ast::HasAttrs for MethodCallExpr {} +impl ast::HasGenericArgs for MethodCallExpr {} impl MethodCallExpr { - pub fn generic_arg_list(&self) -> Option<GenericArgList> { support::child(&self.syntax) } + #[inline] pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } + #[inline] pub fn receiver(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn dot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![.]) } } @@ -799,8 +1019,11 @@ impl ast::HasDocComments for Module {} impl ast::HasName for Module {} impl ast::HasVisibility for Module {} impl Module { + #[inline] pub fn item_list(&self) -> Option<ItemList> { support::child(&self.syntax) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } + #[inline] pub fn mod_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mod]) } } @@ -809,7 +1032,9 @@ pub struct Name { pub(crate) syntax: SyntaxNode, } impl Name { + #[inline] pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) } + #[inline] pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) } } @@ -818,10 +1043,15 @@ pub struct NameRef { pub(crate) syntax: SyntaxNode, } impl NameRef { + #[inline] pub fn Self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![Self]) } + #[inline] pub fn crate_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![crate]) } + #[inline] pub fn ident_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![ident]) } + #[inline] pub fn self_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![self]) } + #[inline] pub fn super_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![super]) } } @@ -830,6 +1060,7 @@ pub struct NeverType { pub(crate) syntax: SyntaxNode, } impl NeverType { + #[inline] pub fn excl_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![!]) } } @@ -839,13 +1070,21 @@ pub struct OffsetOfExpr { } impl ast::HasAttrs for OffsetOfExpr {} impl OffsetOfExpr { + #[inline] pub fn fields(&self) -> AstChildren<NameRef> { support::children(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn pound_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![#]) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } + #[inline] pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) } + #[inline] pub fn builtin_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![builtin]) } + #[inline] pub fn offset_of_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![offset_of]) } @@ -856,6 +1095,7 @@ pub struct OrPat { pub(crate) syntax: SyntaxNode, } impl OrPat { + #[inline] pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) } } @@ -865,9 +1105,13 @@ pub struct Param { } impl ast::HasAttrs for Param {} impl Param { + #[inline] pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn dotdotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![...]) } + #[inline] pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } } @@ -876,11 +1120,17 @@ pub struct ParamList { pub(crate) syntax: SyntaxNode, } impl ParamList { + #[inline] pub fn params(&self) -> AstChildren<Param> { support::children(&self.syntax) } + #[inline] pub fn self_param(&self) -> Option<SelfParam> { support::child(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } + #[inline] pub fn comma_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![,]) } + #[inline] pub fn pipe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![|]) } } @@ -890,8 +1140,11 @@ pub struct ParenExpr { } impl ast::HasAttrs for ParenExpr {} impl ParenExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } } @@ -900,8 +1153,11 @@ pub struct ParenPat { pub(crate) syntax: SyntaxNode, } impl ParenPat { + #[inline] pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } } @@ -910,8 +1166,11 @@ pub struct ParenType { pub(crate) syntax: SyntaxNode, } impl ParenType { + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } } @@ -920,8 +1179,11 @@ pub struct Path { pub(crate) syntax: SyntaxNode, } impl Path { + #[inline] pub fn qualifier(&self) -> Option<Path> { support::child(&self.syntax) } + #[inline] pub fn segment(&self) -> Option<PathSegment> { support::child(&self.syntax) } + #[inline] pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) } } @@ -931,6 +1193,7 @@ pub struct PathExpr { } impl ast::HasAttrs for PathExpr {} impl PathExpr { + #[inline] pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } } @@ -939,6 +1202,7 @@ pub struct PathPat { pub(crate) syntax: SyntaxNode, } impl PathPat { + #[inline] pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } } @@ -946,16 +1210,25 @@ impl PathPat { pub struct PathSegment { pub(crate) syntax: SyntaxNode, } +impl ast::HasGenericArgs for PathSegment {} impl PathSegment { - pub fn generic_arg_list(&self) -> Option<GenericArgList> { support::child(&self.syntax) } + #[inline] pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } + #[inline] pub fn param_list(&self) -> Option<ParamList> { support::child(&self.syntax) } + #[inline] pub fn path_type(&self) -> Option<PathType> { support::child(&self.syntax) } + #[inline] pub fn ret_type(&self) -> Option<RetType> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) } + #[inline] pub fn l_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![<]) } + #[inline] pub fn r_angle_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![>]) } + #[inline] pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) } } @@ -964,6 +1237,7 @@ pub struct PathType { pub(crate) syntax: SyntaxNode, } impl PathType { + #[inline] pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } } @@ -973,6 +1247,7 @@ pub struct PrefixExpr { } impl ast::HasAttrs for PrefixExpr {} impl PrefixExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } } @@ -981,9 +1256,13 @@ pub struct PtrType { pub(crate) syntax: SyntaxNode, } impl PtrType { + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) } + #[inline] pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } + #[inline] pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } } @@ -1005,7 +1284,9 @@ pub struct RecordExpr { pub(crate) syntax: SyntaxNode, } impl RecordExpr { + #[inline] pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } + #[inline] pub fn record_expr_field_list(&self) -> Option<RecordExprFieldList> { support::child(&self.syntax) } @@ -1017,8 +1298,11 @@ pub struct RecordExprField { } impl ast::HasAttrs for RecordExprField {} impl RecordExprField { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } + #[inline] pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } } @@ -1028,10 +1312,15 @@ pub struct RecordExprFieldList { } impl ast::HasAttrs for RecordExprFieldList {} impl RecordExprFieldList { + #[inline] pub fn fields(&self) -> AstChildren<RecordExprField> { support::children(&self.syntax) } + #[inline] pub fn spread(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } + #[inline] pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) } } @@ -1044,7 +1333,9 @@ impl ast::HasDocComments for RecordField {} impl ast::HasName for RecordField {} impl ast::HasVisibility for RecordField {} impl RecordField { + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } } @@ -1053,8 +1344,11 @@ pub struct RecordFieldList { pub(crate) syntax: SyntaxNode, } impl RecordFieldList { + #[inline] pub fn fields(&self) -> AstChildren<RecordField> { support::children(&self.syntax) } + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } } @@ -1063,7 +1357,9 @@ pub struct RecordPat { pub(crate) syntax: SyntaxNode, } impl RecordPat { + #[inline] pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } + #[inline] pub fn record_pat_field_list(&self) -> Option<RecordPatFieldList> { support::child(&self.syntax) } @@ -1075,8 +1371,11 @@ pub struct RecordPatField { } impl ast::HasAttrs for RecordPatField {} impl RecordPatField { + #[inline] pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) } + #[inline] pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + #[inline] pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } } @@ -1085,9 +1384,13 @@ pub struct RecordPatFieldList { pub(crate) syntax: SyntaxNode, } impl RecordPatFieldList { + #[inline] pub fn fields(&self) -> AstChildren<RecordPatField> { support::children(&self.syntax) } + #[inline] pub fn rest_pat(&self) -> Option<RestPat> { support::child(&self.syntax) } + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } } @@ -1097,10 +1400,15 @@ pub struct RefExpr { } impl ast::HasAttrs for RefExpr {} impl RefExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) } + #[inline] pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } + #[inline] pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } + #[inline] pub fn raw_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![raw]) } } @@ -1109,8 +1417,11 @@ pub struct RefPat { pub(crate) syntax: SyntaxNode, } impl RefPat { + #[inline] pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) } + #[inline] pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) } + #[inline] pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } } @@ -1119,9 +1430,13 @@ pub struct RefType { pub(crate) syntax: SyntaxNode, } impl RefType { + #[inline] pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) } + #[inline] pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } } @@ -1131,7 +1446,9 @@ pub struct Rename { } impl ast::HasName for Rename {} impl Rename { + #[inline] pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) } + #[inline] pub fn as_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![as]) } } @@ -1141,6 +1458,7 @@ pub struct RestPat { } impl ast::HasAttrs for RestPat {} impl RestPat { + #[inline] pub fn dotdot_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![..]) } } @@ -1149,7 +1467,9 @@ pub struct RetType { pub(crate) syntax: SyntaxNode, } impl RetType { + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn thin_arrow_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![->]) } } @@ -1159,7 +1479,9 @@ pub struct ReturnExpr { } impl ast::HasAttrs for ReturnExpr {} impl ReturnExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn return_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![return]) } } @@ -1170,10 +1492,15 @@ pub struct SelfParam { impl ast::HasAttrs for SelfParam {} impl ast::HasName for SelfParam {} impl SelfParam { + #[inline] pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn amp_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![&]) } + #[inline] pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } + #[inline] pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } } @@ -1182,8 +1509,11 @@ pub struct SlicePat { pub(crate) syntax: SyntaxNode, } impl SlicePat { + #[inline] pub fn pats(&self) -> AstChildren<Pat> { support::children(&self.syntax) } + #[inline] pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } + #[inline] pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } } @@ -1192,8 +1522,11 @@ pub struct SliceType { pub(crate) syntax: SyntaxNode, } impl SliceType { + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } + #[inline] pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } } @@ -1205,6 +1538,7 @@ impl ast::HasAttrs for SourceFile {} impl ast::HasDocComments for SourceFile {} impl ast::HasModuleItem for SourceFile {} impl SourceFile { + #[inline] pub fn shebang_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![shebang]) } } @@ -1217,11 +1551,17 @@ impl ast::HasDocComments for Static {} impl ast::HasName for Static {} impl ast::HasVisibility for Static {} impl Static { + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn colon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![:]) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + #[inline] pub fn mut_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![mut]) } + #[inline] pub fn static_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![static]) } } @@ -1231,9 +1571,13 @@ pub struct StmtList { } impl ast::HasAttrs for StmtList {} impl StmtList { + #[inline] pub fn statements(&self) -> AstChildren<Stmt> { support::children(&self.syntax) } + #[inline] pub fn tail_expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } } @@ -1247,8 +1591,11 @@ impl ast::HasGenericParams for Struct {} impl ast::HasName for Struct {} impl ast::HasVisibility for Struct {} impl Struct { + #[inline] pub fn field_list(&self) -> Option<FieldList> { support::child(&self.syntax) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } + #[inline] pub fn struct_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![struct]) } } @@ -1257,11 +1604,17 @@ pub struct TokenTree { pub(crate) syntax: SyntaxNode, } impl TokenTree { + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } + #[inline] pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['[']) } + #[inline] pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![']']) } + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } } @@ -1276,9 +1629,13 @@ impl ast::HasName for Trait {} impl ast::HasTypeBounds for Trait {} impl ast::HasVisibility for Trait {} impl Trait { + #[inline] pub fn assoc_item_list(&self) -> Option<AssocItemList> { support::child(&self.syntax) } + #[inline] pub fn auto_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![auto]) } + #[inline] pub fn trait_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![trait]) } + #[inline] pub fn unsafe_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![unsafe]) } } @@ -1292,9 +1649,13 @@ impl ast::HasGenericParams for TraitAlias {} impl ast::HasName for TraitAlias {} impl ast::HasVisibility for TraitAlias {} impl TraitAlias { + #[inline] pub fn type_bound_list(&self) -> Option<TypeBoundList> { support::child(&self.syntax) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + #[inline] pub fn trait_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![trait]) } } @@ -1304,7 +1665,9 @@ pub struct TryExpr { } impl ast::HasAttrs for TryExpr {} impl TryExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) } } @@ -1314,8 +1677,11 @@ pub struct TupleExpr { } impl ast::HasAttrs for TupleExpr {} impl TupleExpr { + #[inline] pub fn fields(&self) -> AstChildren<Expr> { support::children(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } } @@ -1327,6 +1693,7 @@ impl ast::HasAttrs for TupleField {} impl ast::HasDocComments for TupleField {} impl ast::HasVisibility for TupleField {} impl TupleField { + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } } @@ -1335,8 +1702,11 @@ pub struct TupleFieldList { pub(crate) syntax: SyntaxNode, } impl TupleFieldList { + #[inline] pub fn fields(&self) -> AstChildren<TupleField> { support::children(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } } @@ -1345,8 +1715,11 @@ pub struct TuplePat { pub(crate) syntax: SyntaxNode, } impl TuplePat { + #[inline] pub fn fields(&self) -> AstChildren<Pat> { support::children(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } } @@ -1355,9 +1728,13 @@ pub struct TupleStructPat { pub(crate) syntax: SyntaxNode, } impl TupleStructPat { + #[inline] pub fn fields(&self) -> AstChildren<Pat> { support::children(&self.syntax) } + #[inline] pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } } @@ -1366,8 +1743,11 @@ pub struct TupleType { pub(crate) syntax: SyntaxNode, } impl TupleType { + #[inline] pub fn fields(&self) -> AstChildren<Type> { support::children(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } } @@ -1382,10 +1762,15 @@ impl ast::HasName for TypeAlias {} impl ast::HasTypeBounds for TypeAlias {} impl ast::HasVisibility for TypeAlias {} impl TypeAlias { + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } + #[inline] pub fn default_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![default]) } + #[inline] pub fn type_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![type]) } } @@ -1394,6 +1779,7 @@ pub struct TypeArg { pub(crate) syntax: SyntaxNode, } impl TypeArg { + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } } @@ -1402,11 +1788,17 @@ pub struct TypeBound { pub(crate) syntax: SyntaxNode, } impl TypeBound { + #[inline] pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn question_mark_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![?]) } + #[inline] pub fn async_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![async]) } + #[inline] pub fn const_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![const]) } + #[inline] pub fn tilde_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![~]) } } @@ -1415,6 +1807,7 @@ pub struct TypeBoundList { pub(crate) syntax: SyntaxNode, } impl TypeBoundList { + #[inline] pub fn bounds(&self) -> AstChildren<TypeBound> { support::children(&self.syntax) } } @@ -1426,7 +1819,9 @@ impl ast::HasAttrs for TypeParam {} impl ast::HasName for TypeParam {} impl ast::HasTypeBounds for TypeParam {} impl TypeParam { + #[inline] pub fn default_type(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } } @@ -1436,6 +1831,7 @@ pub struct UnderscoreExpr { } impl ast::HasAttrs for UnderscoreExpr {} impl UnderscoreExpr { + #[inline] pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) } } @@ -1449,7 +1845,9 @@ impl ast::HasGenericParams for Union {} impl ast::HasName for Union {} impl ast::HasVisibility for Union {} impl Union { + #[inline] pub fn record_field_list(&self) -> Option<RecordFieldList> { support::child(&self.syntax) } + #[inline] pub fn union_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![union]) } } @@ -1461,8 +1859,11 @@ impl ast::HasAttrs for Use {} impl ast::HasDocComments for Use {} impl ast::HasVisibility for Use {} impl Use { + #[inline] pub fn use_tree(&self) -> Option<UseTree> { support::child(&self.syntax) } + #[inline] pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![;]) } + #[inline] pub fn use_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![use]) } } @@ -1471,10 +1872,15 @@ pub struct UseTree { pub(crate) syntax: SyntaxNode, } impl UseTree { + #[inline] pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } + #[inline] pub fn rename(&self) -> Option<Rename> { support::child(&self.syntax) } + #[inline] pub fn use_tree_list(&self) -> Option<UseTreeList> { support::child(&self.syntax) } + #[inline] pub fn star_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![*]) } + #[inline] pub fn coloncolon_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![::]) } } @@ -1483,8 +1889,11 @@ pub struct UseTreeList { pub(crate) syntax: SyntaxNode, } impl UseTreeList { + #[inline] pub fn use_trees(&self) -> AstChildren<UseTree> { support::children(&self.syntax) } + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } } @@ -1497,8 +1906,11 @@ impl ast::HasDocComments for Variant {} impl ast::HasName for Variant {} impl ast::HasVisibility for Variant {} impl Variant { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn field_list(&self) -> Option<FieldList> { support::child(&self.syntax) } + #[inline] pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) } } @@ -1507,8 +1919,11 @@ pub struct VariantList { pub(crate) syntax: SyntaxNode, } impl VariantList { + #[inline] pub fn variants(&self) -> AstChildren<Variant> { support::children(&self.syntax) } + #[inline] pub fn l_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['{']) } + #[inline] pub fn r_curly_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['}']) } } @@ -1517,10 +1932,15 @@ pub struct Visibility { pub(crate) syntax: SyntaxNode, } impl Visibility { + #[inline] pub fn path(&self) -> Option<Path> { support::child(&self.syntax) } + #[inline] pub fn l_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T!['(']) } + #[inline] pub fn r_paren_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![')']) } + #[inline] pub fn in_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![in]) } + #[inline] pub fn pub_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![pub]) } } @@ -1529,7 +1949,9 @@ pub struct WhereClause { pub(crate) syntax: SyntaxNode, } impl WhereClause { + #[inline] pub fn predicates(&self) -> AstChildren<WherePred> { support::children(&self.syntax) } + #[inline] pub fn where_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![where]) } } @@ -1539,9 +1961,13 @@ pub struct WherePred { } impl ast::HasTypeBounds for WherePred {} impl WherePred { + #[inline] pub fn generic_param_list(&self) -> Option<GenericParamList> { support::child(&self.syntax) } + #[inline] pub fn lifetime(&self) -> Option<Lifetime> { support::child(&self.syntax) } + #[inline] pub fn ty(&self) -> Option<Type> { support::child(&self.syntax) } + #[inline] pub fn for_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![for]) } } @@ -1551,6 +1977,7 @@ pub struct WhileExpr { } impl ast::HasAttrs for WhileExpr {} impl WhileExpr { + #[inline] pub fn while_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![while]) } } @@ -1559,6 +1986,7 @@ pub struct WildcardPat { pub(crate) syntax: SyntaxNode, } impl WildcardPat { + #[inline] pub fn underscore_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![_]) } } @@ -1568,8 +1996,11 @@ pub struct YeetExpr { } impl ast::HasAttrs for YeetExpr {} impl YeetExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn do_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![do]) } + #[inline] pub fn yeet_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![yeet]) } } @@ -1579,7 +2010,9 @@ pub struct YieldExpr { } impl ast::HasAttrs for YieldExpr {} impl YieldExpr { + #[inline] pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) } + #[inline] pub fn yield_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![yield]) } } @@ -1764,6 +2197,12 @@ pub struct AnyHasDocComments { impl ast::HasDocComments for AnyHasDocComments {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AnyHasGenericArgs { + pub(crate) syntax: SyntaxNode, +} +impl ast::HasGenericArgs for AnyHasGenericArgs {} + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct AnyHasGenericParams { pub(crate) syntax: SyntaxNode, } @@ -1799,7 +2238,9 @@ pub struct AnyHasVisibility { } impl ast::HasVisibility for AnyHasVisibility {} impl AstNode for Abi { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ABI } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1807,10 +2248,13 @@ impl AstNode for Abi { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ArgList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ARG_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1818,10 +2262,13 @@ impl AstNode for ArgList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ArrayExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1829,10 +2276,13 @@ impl AstNode for ArrayExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ArrayType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ARRAY_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1840,10 +2290,13 @@ impl AstNode for ArrayType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for AsmExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ASM_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1851,10 +2304,13 @@ impl AstNode for AsmExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for AssocItemList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ASSOC_ITEM_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1862,10 +2318,13 @@ impl AstNode for AssocItemList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for AssocTypeArg { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ASSOC_TYPE_ARG } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1873,10 +2332,13 @@ impl AstNode for AssocTypeArg { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Attr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ATTR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1884,10 +2346,13 @@ impl AstNode for Attr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for AwaitExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == AWAIT_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1895,10 +2360,13 @@ impl AstNode for AwaitExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for BecomeExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == BECOME_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1906,10 +2374,13 @@ impl AstNode for BecomeExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for BinExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == BIN_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1917,10 +2388,13 @@ impl AstNode for BinExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for BlockExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == BLOCK_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1928,10 +2402,13 @@ impl AstNode for BlockExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for BoxPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == BOX_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1939,10 +2416,13 @@ impl AstNode for BoxPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for BreakExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == BREAK_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1950,10 +2430,13 @@ impl AstNode for BreakExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for CallExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CALL_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1961,10 +2444,13 @@ impl AstNode for CallExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for CastExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CAST_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1972,10 +2458,13 @@ impl AstNode for CastExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ClosureExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CLOSURE_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1983,10 +2472,13 @@ impl AstNode for ClosureExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Const { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CONST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -1994,10 +2486,13 @@ impl AstNode for Const { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ConstArg { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_ARG } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2005,10 +2500,13 @@ impl AstNode for ConstArg { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ConstBlockPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_BLOCK_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2016,10 +2514,13 @@ impl AstNode for ConstBlockPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ConstParam { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CONST_PARAM } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2027,10 +2528,13 @@ impl AstNode for ConstParam { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ContinueExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == CONTINUE_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2038,10 +2542,13 @@ impl AstNode for ContinueExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for DynTraitType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == DYN_TRAIT_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2049,10 +2556,13 @@ impl AstNode for DynTraitType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Enum { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ENUM } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2060,10 +2570,13 @@ impl AstNode for Enum { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ExprStmt { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == EXPR_STMT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2071,10 +2584,13 @@ impl AstNode for ExprStmt { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ExternBlock { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_BLOCK } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2082,10 +2598,13 @@ impl AstNode for ExternBlock { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ExternCrate { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_CRATE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2093,10 +2612,13 @@ impl AstNode for ExternCrate { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ExternItemList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == EXTERN_ITEM_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2104,10 +2626,13 @@ impl AstNode for ExternItemList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for FieldExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == FIELD_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2115,10 +2640,13 @@ impl AstNode for FieldExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Fn { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == FN } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2126,10 +2654,13 @@ impl AstNode for Fn { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for FnPtrType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == FN_PTR_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2137,10 +2668,13 @@ impl AstNode for FnPtrType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ForExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2148,10 +2682,13 @@ impl AstNode for ForExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ForType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == FOR_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2159,10 +2696,13 @@ impl AstNode for ForType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for FormatArgsArg { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == FORMAT_ARGS_ARG } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2170,10 +2710,13 @@ impl AstNode for FormatArgsArg { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for FormatArgsExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == FORMAT_ARGS_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2181,10 +2724,13 @@ impl AstNode for FormatArgsExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for GenericArgList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == GENERIC_ARG_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2192,10 +2738,13 @@ impl AstNode for GenericArgList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for GenericParamList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == GENERIC_PARAM_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2203,10 +2752,13 @@ impl AstNode for GenericParamList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for IdentPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == IDENT_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2214,10 +2766,13 @@ impl AstNode for IdentPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for IfExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == IF_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2225,10 +2780,13 @@ impl AstNode for IfExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Impl { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2236,10 +2794,13 @@ impl AstNode for Impl { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ImplTraitType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == IMPL_TRAIT_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2247,10 +2808,13 @@ impl AstNode for ImplTraitType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for IndexExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == INDEX_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2258,10 +2822,13 @@ impl AstNode for IndexExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for InferType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == INFER_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2269,10 +2836,13 @@ impl AstNode for InferType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ItemList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == ITEM_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2280,10 +2850,13 @@ impl AstNode for ItemList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Label { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LABEL } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2291,10 +2864,13 @@ impl AstNode for Label { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for LetElse { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LET_ELSE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2302,10 +2878,13 @@ impl AstNode for LetElse { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for LetExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LET_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2313,10 +2892,13 @@ impl AstNode for LetExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for LetStmt { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LET_STMT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2324,10 +2906,13 @@ impl AstNode for LetStmt { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Lifetime { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2335,10 +2920,13 @@ impl AstNode for Lifetime { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for LifetimeArg { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_ARG } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2346,10 +2934,13 @@ impl AstNode for LifetimeArg { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for LifetimeParam { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LIFETIME_PARAM } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2357,10 +2948,13 @@ impl AstNode for LifetimeParam { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Literal { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2368,10 +2962,13 @@ impl AstNode for Literal { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for LiteralPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LITERAL_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2379,10 +2976,13 @@ impl AstNode for LiteralPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for LoopExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == LOOP_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2390,10 +2990,13 @@ impl AstNode for LoopExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MacroCall { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_CALL } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2401,10 +3004,13 @@ impl AstNode for MacroCall { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MacroDef { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_DEF } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2412,10 +3018,13 @@ impl AstNode for MacroDef { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MacroEagerInput { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_EAGER_INPUT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2423,10 +3032,13 @@ impl AstNode for MacroEagerInput { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MacroExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2434,10 +3046,13 @@ impl AstNode for MacroExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MacroItems { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_ITEMS } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2445,10 +3060,13 @@ impl AstNode for MacroItems { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MacroPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2456,10 +3074,13 @@ impl AstNode for MacroPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MacroRules { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_RULES } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2467,10 +3088,13 @@ impl AstNode for MacroRules { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MacroStmts { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_STMTS } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2478,10 +3102,13 @@ impl AstNode for MacroStmts { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MacroType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MACRO_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2489,10 +3116,13 @@ impl AstNode for MacroType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MatchArm { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2500,10 +3130,13 @@ impl AstNode for MatchArm { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MatchArmList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_ARM_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2511,10 +3144,13 @@ impl AstNode for MatchArmList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MatchExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2522,10 +3158,13 @@ impl AstNode for MatchExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MatchGuard { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MATCH_GUARD } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2533,10 +3172,13 @@ impl AstNode for MatchGuard { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Meta { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == META } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2544,10 +3186,13 @@ impl AstNode for Meta { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for MethodCallExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == METHOD_CALL_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2555,10 +3200,13 @@ impl AstNode for MethodCallExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Module { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == MODULE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2566,10 +3214,13 @@ impl AstNode for Module { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Name { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == NAME } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2577,10 +3228,13 @@ impl AstNode for Name { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for NameRef { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == NAME_REF } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2588,10 +3242,13 @@ impl AstNode for NameRef { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for NeverType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == NEVER_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2599,10 +3256,13 @@ impl AstNode for NeverType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for OffsetOfExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == OFFSET_OF_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2610,10 +3270,13 @@ impl AstNode for OffsetOfExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for OrPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == OR_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2621,10 +3284,13 @@ impl AstNode for OrPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Param { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2632,10 +3298,13 @@ impl AstNode for Param { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ParamList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PARAM_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2643,10 +3312,13 @@ impl AstNode for ParamList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ParenExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2654,10 +3326,13 @@ impl AstNode for ParenExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ParenPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2665,10 +3340,13 @@ impl AstNode for ParenPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ParenType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PAREN_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2676,10 +3354,13 @@ impl AstNode for ParenType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Path { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PATH } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2687,10 +3368,13 @@ impl AstNode for Path { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for PathExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2698,10 +3382,13 @@ impl AstNode for PathExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for PathPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2709,10 +3396,13 @@ impl AstNode for PathPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for PathSegment { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_SEGMENT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2720,10 +3410,13 @@ impl AstNode for PathSegment { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for PathType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PATH_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2731,10 +3424,13 @@ impl AstNode for PathType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for PrefixExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PREFIX_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2742,10 +3438,13 @@ impl AstNode for PrefixExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for PtrType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == PTR_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2753,10 +3452,13 @@ impl AstNode for PtrType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RangeExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2764,10 +3466,13 @@ impl AstNode for RangeExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RangePat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RANGE_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2775,10 +3480,13 @@ impl AstNode for RangePat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RecordExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2786,10 +3494,13 @@ impl AstNode for RecordExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RecordExprField { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR_FIELD } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2797,10 +3508,13 @@ impl AstNode for RecordExprField { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RecordExprFieldList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_EXPR_FIELD_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2808,10 +3522,13 @@ impl AstNode for RecordExprFieldList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RecordField { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2819,10 +3536,13 @@ impl AstNode for RecordField { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RecordFieldList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_FIELD_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2830,10 +3550,13 @@ impl AstNode for RecordFieldList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RecordPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2841,10 +3564,13 @@ impl AstNode for RecordPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RecordPatField { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT_FIELD } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2852,10 +3578,13 @@ impl AstNode for RecordPatField { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RecordPatFieldList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RECORD_PAT_FIELD_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2863,10 +3592,13 @@ impl AstNode for RecordPatFieldList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RefExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == REF_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2874,10 +3606,13 @@ impl AstNode for RefExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RefPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == REF_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2885,10 +3620,13 @@ impl AstNode for RefPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RefType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == REF_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2896,10 +3634,13 @@ impl AstNode for RefType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Rename { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RENAME } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2907,10 +3648,13 @@ impl AstNode for Rename { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RestPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == REST_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2918,10 +3662,13 @@ impl AstNode for RestPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for RetType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RET_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2929,10 +3676,13 @@ impl AstNode for RetType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for ReturnExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == RETURN_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2940,10 +3690,13 @@ impl AstNode for ReturnExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for SelfParam { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == SELF_PARAM } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2951,10 +3704,13 @@ impl AstNode for SelfParam { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for SlicePat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2962,10 +3718,13 @@ impl AstNode for SlicePat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for SliceType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == SLICE_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2973,10 +3732,13 @@ impl AstNode for SliceType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for SourceFile { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == SOURCE_FILE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2984,10 +3746,13 @@ impl AstNode for SourceFile { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Static { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == STATIC } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -2995,10 +3760,13 @@ impl AstNode for Static { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for StmtList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == STMT_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3006,10 +3774,13 @@ impl AstNode for StmtList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Struct { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == STRUCT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3017,10 +3788,13 @@ impl AstNode for Struct { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TokenTree { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TOKEN_TREE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3028,10 +3802,13 @@ impl AstNode for TokenTree { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Trait { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TRAIT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3039,10 +3816,13 @@ impl AstNode for Trait { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TraitAlias { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TRAIT_ALIAS } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3050,10 +3830,13 @@ impl AstNode for TraitAlias { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TryExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TRY_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3061,10 +3844,13 @@ impl AstNode for TryExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TupleExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3072,10 +3858,13 @@ impl AstNode for TupleExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TupleField { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3083,10 +3872,13 @@ impl AstNode for TupleField { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TupleFieldList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_FIELD_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3094,10 +3886,13 @@ impl AstNode for TupleFieldList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TuplePat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3105,10 +3900,13 @@ impl AstNode for TuplePat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TupleStructPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_STRUCT_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3116,10 +3914,13 @@ impl AstNode for TupleStructPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TupleType { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TUPLE_TYPE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3127,10 +3928,13 @@ impl AstNode for TupleType { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TypeAlias { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ALIAS } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3138,10 +3942,13 @@ impl AstNode for TypeAlias { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TypeArg { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_ARG } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3149,10 +3956,13 @@ impl AstNode for TypeArg { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TypeBound { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3160,10 +3970,13 @@ impl AstNode for TypeBound { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TypeBoundList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_BOUND_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3171,10 +3984,13 @@ impl AstNode for TypeBoundList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for TypeParam { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == TYPE_PARAM } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3182,10 +3998,13 @@ impl AstNode for TypeParam { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for UnderscoreExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == UNDERSCORE_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3193,10 +4012,13 @@ impl AstNode for UnderscoreExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Union { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == UNION } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3204,10 +4026,13 @@ impl AstNode for Union { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Use { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == USE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3215,10 +4040,13 @@ impl AstNode for Use { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for UseTree { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3226,10 +4054,13 @@ impl AstNode for UseTree { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for UseTreeList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == USE_TREE_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3237,10 +4068,13 @@ impl AstNode for UseTreeList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Variant { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == VARIANT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3248,10 +4082,13 @@ impl AstNode for Variant { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for VariantList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == VARIANT_LIST } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3259,10 +4096,13 @@ impl AstNode for VariantList { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for Visibility { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == VISIBILITY } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3270,10 +4110,13 @@ impl AstNode for Visibility { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for WhereClause { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_CLAUSE } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3281,10 +4124,13 @@ impl AstNode for WhereClause { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for WherePred { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == WHERE_PRED } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3292,10 +4138,13 @@ impl AstNode for WherePred { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for WhileExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == WHILE_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3303,10 +4152,13 @@ impl AstNode for WhileExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for WildcardPat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == WILDCARD_PAT } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3314,10 +4166,13 @@ impl AstNode for WildcardPat { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for YeetExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == YEET_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3325,10 +4180,13 @@ impl AstNode for YeetExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AstNode for YieldExpr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == YIELD_EXPR } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) @@ -3336,19 +4194,25 @@ impl AstNode for YieldExpr { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl From<Enum> for Adt { + #[inline] fn from(node: Enum) -> Adt { Adt::Enum(node) } } impl From<Struct> for Adt { + #[inline] fn from(node: Struct) -> Adt { Adt::Struct(node) } } impl From<Union> for Adt { + #[inline] fn from(node: Union) -> Adt { Adt::Union(node) } } impl AstNode for Adt { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, ENUM | STRUCT | UNION) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { let res = match syntax.kind() { ENUM => Adt::Enum(Enum { syntax }), @@ -3358,6 +4222,7 @@ impl AstNode for Adt { }; Some(res) } + #[inline] fn syntax(&self) -> &SyntaxNode { match self { Adt::Enum(it) => &it.syntax, @@ -3367,19 +4232,25 @@ impl AstNode for Adt { } } impl From<Const> for AssocItem { + #[inline] fn from(node: Const) -> AssocItem { AssocItem::Const(node) } } impl From<Fn> for AssocItem { + #[inline] fn from(node: Fn) -> AssocItem { AssocItem::Fn(node) } } impl From<MacroCall> for AssocItem { + #[inline] fn from(node: MacroCall) -> AssocItem { AssocItem::MacroCall(node) } } impl From<TypeAlias> for AssocItem { + #[inline] fn from(node: TypeAlias) -> AssocItem { AssocItem::TypeAlias(node) } } impl AstNode for AssocItem { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, CONST | FN | MACRO_CALL | TYPE_ALIAS) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { let res = match syntax.kind() { CONST => AssocItem::Const(Const { syntax }), @@ -3390,6 +4261,7 @@ impl AstNode for AssocItem { }; Some(res) } + #[inline] fn syntax(&self) -> &SyntaxNode { match self { AssocItem::Const(it) => &it.syntax, @@ -3400,114 +4272,151 @@ impl AstNode for AssocItem { } } impl From<ArrayExpr> for Expr { + #[inline] fn from(node: ArrayExpr) -> Expr { Expr::ArrayExpr(node) } } impl From<AsmExpr> for Expr { + #[inline] fn from(node: AsmExpr) -> Expr { Expr::AsmExpr(node) } } impl From<AwaitExpr> for Expr { + #[inline] fn from(node: AwaitExpr) -> Expr { Expr::AwaitExpr(node) } } impl From<BecomeExpr> for Expr { + #[inline] fn from(node: BecomeExpr) -> Expr { Expr::BecomeExpr(node) } } impl From<BinExpr> for Expr { + #[inline] fn from(node: BinExpr) -> Expr { Expr::BinExpr(node) } } impl From<BlockExpr> for Expr { + #[inline] fn from(node: BlockExpr) -> Expr { Expr::BlockExpr(node) } } impl From<BreakExpr> for Expr { + #[inline] fn from(node: BreakExpr) -> Expr { Expr::BreakExpr(node) } } impl From<CallExpr> for Expr { + #[inline] fn from(node: CallExpr) -> Expr { Expr::CallExpr(node) } } impl From<CastExpr> for Expr { + #[inline] fn from(node: CastExpr) -> Expr { Expr::CastExpr(node) } } impl From<ClosureExpr> for Expr { + #[inline] fn from(node: ClosureExpr) -> Expr { Expr::ClosureExpr(node) } } impl From<ContinueExpr> for Expr { + #[inline] fn from(node: ContinueExpr) -> Expr { Expr::ContinueExpr(node) } } impl From<FieldExpr> for Expr { + #[inline] fn from(node: FieldExpr) -> Expr { Expr::FieldExpr(node) } } impl From<ForExpr> for Expr { + #[inline] fn from(node: ForExpr) -> Expr { Expr::ForExpr(node) } } impl From<FormatArgsExpr> for Expr { + #[inline] fn from(node: FormatArgsExpr) -> Expr { Expr::FormatArgsExpr(node) } } impl From<IfExpr> for Expr { + #[inline] fn from(node: IfExpr) -> Expr { Expr::IfExpr(node) } } impl From<IndexExpr> for Expr { + #[inline] fn from(node: IndexExpr) -> Expr { Expr::IndexExpr(node) } } impl From<LetExpr> for Expr { + #[inline] fn from(node: LetExpr) -> Expr { Expr::LetExpr(node) } } impl From<Literal> for Expr { + #[inline] fn from(node: Literal) -> Expr { Expr::Literal(node) } } impl From<LoopExpr> for Expr { + #[inline] fn from(node: LoopExpr) -> Expr { Expr::LoopExpr(node) } } impl From<MacroExpr> for Expr { + #[inline] fn from(node: MacroExpr) -> Expr { Expr::MacroExpr(node) } } impl From<MatchExpr> for Expr { + #[inline] fn from(node: MatchExpr) -> Expr { Expr::MatchExpr(node) } } impl From<MethodCallExpr> for Expr { + #[inline] fn from(node: MethodCallExpr) -> Expr { Expr::MethodCallExpr(node) } } impl From<OffsetOfExpr> for Expr { + #[inline] fn from(node: OffsetOfExpr) -> Expr { Expr::OffsetOfExpr(node) } } impl From<ParenExpr> for Expr { + #[inline] fn from(node: ParenExpr) -> Expr { Expr::ParenExpr(node) } } impl From<PathExpr> for Expr { + #[inline] fn from(node: PathExpr) -> Expr { Expr::PathExpr(node) } } impl From<PrefixExpr> for Expr { + #[inline] fn from(node: PrefixExpr) -> Expr { Expr::PrefixExpr(node) } } impl From<RangeExpr> for Expr { + #[inline] fn from(node: RangeExpr) -> Expr { Expr::RangeExpr(node) } } impl From<RecordExpr> for Expr { + #[inline] fn from(node: RecordExpr) -> Expr { Expr::RecordExpr(node) } } impl From<RefExpr> for Expr { + #[inline] fn from(node: RefExpr) -> Expr { Expr::RefExpr(node) } } impl From<ReturnExpr> for Expr { + #[inline] fn from(node: ReturnExpr) -> Expr { Expr::ReturnExpr(node) } } impl From<TryExpr> for Expr { + #[inline] fn from(node: TryExpr) -> Expr { Expr::TryExpr(node) } } impl From<TupleExpr> for Expr { + #[inline] fn from(node: TupleExpr) -> Expr { Expr::TupleExpr(node) } } impl From<UnderscoreExpr> for Expr { + #[inline] fn from(node: UnderscoreExpr) -> Expr { Expr::UnderscoreExpr(node) } } impl From<WhileExpr> for Expr { + #[inline] fn from(node: WhileExpr) -> Expr { Expr::WhileExpr(node) } } impl From<YeetExpr> for Expr { + #[inline] fn from(node: YeetExpr) -> Expr { Expr::YeetExpr(node) } } impl From<YieldExpr> for Expr { + #[inline] fn from(node: YieldExpr) -> Expr { Expr::YieldExpr(node) } } impl AstNode for Expr { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!( kind, @@ -3549,6 +4458,7 @@ impl AstNode for Expr { | YIELD_EXPR ) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { let res = match syntax.kind() { ARRAY_EXPR => Expr::ArrayExpr(ArrayExpr { syntax }), @@ -3591,6 +4501,7 @@ impl AstNode for Expr { }; Some(res) } + #[inline] fn syntax(&self) -> &SyntaxNode { match self { Expr::ArrayExpr(it) => &it.syntax, @@ -3633,19 +4544,25 @@ impl AstNode for Expr { } } impl From<Fn> for ExternItem { + #[inline] fn from(node: Fn) -> ExternItem { ExternItem::Fn(node) } } impl From<MacroCall> for ExternItem { + #[inline] fn from(node: MacroCall) -> ExternItem { ExternItem::MacroCall(node) } } impl From<Static> for ExternItem { + #[inline] fn from(node: Static) -> ExternItem { ExternItem::Static(node) } } impl From<TypeAlias> for ExternItem { + #[inline] fn from(node: TypeAlias) -> ExternItem { ExternItem::TypeAlias(node) } } impl AstNode for ExternItem { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, FN | MACRO_CALL | STATIC | TYPE_ALIAS) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { let res = match syntax.kind() { FN => ExternItem::Fn(Fn { syntax }), @@ -3656,6 +4573,7 @@ impl AstNode for ExternItem { }; Some(res) } + #[inline] fn syntax(&self) -> &SyntaxNode { match self { ExternItem::Fn(it) => &it.syntax, @@ -3666,13 +4584,17 @@ impl AstNode for ExternItem { } } impl From<RecordFieldList> for FieldList { + #[inline] fn from(node: RecordFieldList) -> FieldList { FieldList::RecordFieldList(node) } } impl From<TupleFieldList> for FieldList { + #[inline] fn from(node: TupleFieldList) -> FieldList { FieldList::TupleFieldList(node) } } impl AstNode for FieldList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, RECORD_FIELD_LIST | TUPLE_FIELD_LIST) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { let res = match syntax.kind() { RECORD_FIELD_LIST => FieldList::RecordFieldList(RecordFieldList { syntax }), @@ -3681,6 +4603,7 @@ impl AstNode for FieldList { }; Some(res) } + #[inline] fn syntax(&self) -> &SyntaxNode { match self { FieldList::RecordFieldList(it) => &it.syntax, @@ -3689,21 +4612,27 @@ impl AstNode for FieldList { } } impl From<AssocTypeArg> for GenericArg { + #[inline] fn from(node: AssocTypeArg) -> GenericArg { GenericArg::AssocTypeArg(node) } } impl From<ConstArg> for GenericArg { + #[inline] fn from(node: ConstArg) -> GenericArg { GenericArg::ConstArg(node) } } impl From<LifetimeArg> for GenericArg { + #[inline] fn from(node: LifetimeArg) -> GenericArg { GenericArg::LifetimeArg(node) } } impl From<TypeArg> for GenericArg { + #[inline] fn from(node: TypeArg) -> GenericArg { GenericArg::TypeArg(node) } } impl AstNode for GenericArg { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, ASSOC_TYPE_ARG | CONST_ARG | LIFETIME_ARG | TYPE_ARG) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { let res = match syntax.kind() { ASSOC_TYPE_ARG => GenericArg::AssocTypeArg(AssocTypeArg { syntax }), @@ -3714,6 +4643,7 @@ impl AstNode for GenericArg { }; Some(res) } + #[inline] fn syntax(&self) -> &SyntaxNode { match self { GenericArg::AssocTypeArg(it) => &it.syntax, @@ -3724,18 +4654,23 @@ impl AstNode for GenericArg { } } impl From<ConstParam> for GenericParam { + #[inline] fn from(node: ConstParam) -> GenericParam { GenericParam::ConstParam(node) } } impl From<LifetimeParam> for GenericParam { + #[inline] fn from(node: LifetimeParam) -> GenericParam { GenericParam::LifetimeParam(node) } } impl From<TypeParam> for GenericParam { + #[inline] fn from(node: TypeParam) -> GenericParam { GenericParam::TypeParam(node) } } impl AstNode for GenericParam { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, CONST_PARAM | LIFETIME_PARAM | TYPE_PARAM) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { let res = match syntax.kind() { CONST_PARAM => GenericParam::ConstParam(ConstParam { syntax }), @@ -3745,6 +4680,7 @@ impl AstNode for GenericParam { }; Some(res) } + #[inline] fn syntax(&self) -> &SyntaxNode { match self { GenericParam::ConstParam(it) => &it.syntax, @@ -3754,57 +4690,75 @@ impl AstNode for GenericParam { } } impl From<Const> for Item { + #[inline] fn from(node: Const) -> Item { Item::Const(node) } } impl From<Enum> for Item { + #[inline] fn from(node: Enum) -> Item { Item::Enum(node) } } impl From<ExternBlock> for Item { + #[inline] fn from(node: ExternBlock) -> Item { Item::ExternBlock(node) } } impl From<ExternCrate> for Item { + #[inline] fn from(node: ExternCrate) -> Item { Item::ExternCrate(node) } } impl From<Fn> for Item { + #[inline] fn from(node: Fn) -> Item { Item::Fn(node) } } impl From<Impl> for Item { + #[inline] fn from(node: Impl) -> Item { Item::Impl(node) } } impl From<MacroCall> for Item { + #[inline] fn from(node: MacroCall) -> Item { Item::MacroCall(node) } } impl From<MacroDef> for Item { + #[inline] fn from(node: MacroDef) -> Item { Item::MacroDef(node) } } impl From<MacroRules> for Item { + #[inline] fn from(node: MacroRules) -> Item { Item::MacroRules(node) } } impl From<Module> for Item { + #[inline] fn from(node: Module) -> Item { Item::Module(node) } } impl From<Static> for Item { + #[inline] fn from(node: Static) -> Item { Item::Static(node) } } impl From<Struct> for Item { + #[inline] fn from(node: Struct) -> Item { Item::Struct(node) } } impl From<Trait> for Item { + #[inline] fn from(node: Trait) -> Item { Item::Trait(node) } } impl From<TraitAlias> for Item { + #[inline] fn from(node: TraitAlias) -> Item { Item::TraitAlias(node) } } impl From<TypeAlias> for Item { + #[inline] fn from(node: TypeAlias) -> Item { Item::TypeAlias(node) } } impl From<Union> for Item { + #[inline] fn from(node: Union) -> Item { Item::Union(node) } } impl From<Use> for Item { + #[inline] fn from(node: Use) -> Item { Item::Use(node) } } impl AstNode for Item { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!( kind, @@ -3827,6 +4781,7 @@ impl AstNode for Item { | USE ) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { let res = match syntax.kind() { CONST => Item::Const(Const { syntax }), @@ -3850,6 +4805,7 @@ impl AstNode for Item { }; Some(res) } + #[inline] fn syntax(&self) -> &SyntaxNode { match self { Item::Const(it) => &it.syntax, @@ -3873,54 +4829,71 @@ impl AstNode for Item { } } impl From<BoxPat> for Pat { + #[inline] fn from(node: BoxPat) -> Pat { Pat::BoxPat(node) } } impl From<ConstBlockPat> for Pat { + #[inline] fn from(node: ConstBlockPat) -> Pat { Pat::ConstBlockPat(node) } } impl From<IdentPat> for Pat { + #[inline] fn from(node: IdentPat) -> Pat { Pat::IdentPat(node) } } impl From<LiteralPat> for Pat { + #[inline] fn from(node: LiteralPat) -> Pat { Pat::LiteralPat(node) } } impl From<MacroPat> for Pat { + #[inline] fn from(node: MacroPat) -> Pat { Pat::MacroPat(node) } } impl From<OrPat> for Pat { + #[inline] fn from(node: OrPat) -> Pat { Pat::OrPat(node) } } impl From<ParenPat> for Pat { + #[inline] fn from(node: ParenPat) -> Pat { Pat::ParenPat(node) } } impl From<PathPat> for Pat { + #[inline] fn from(node: PathPat) -> Pat { Pat::PathPat(node) } } impl From<RangePat> for Pat { + #[inline] fn from(node: RangePat) -> Pat { Pat::RangePat(node) } } impl From<RecordPat> for Pat { + #[inline] fn from(node: RecordPat) -> Pat { Pat::RecordPat(node) } } impl From<RefPat> for Pat { + #[inline] fn from(node: RefPat) -> Pat { Pat::RefPat(node) } } impl From<RestPat> for Pat { + #[inline] fn from(node: RestPat) -> Pat { Pat::RestPat(node) } } impl From<SlicePat> for Pat { + #[inline] fn from(node: SlicePat) -> Pat { Pat::SlicePat(node) } } impl From<TuplePat> for Pat { + #[inline] fn from(node: TuplePat) -> Pat { Pat::TuplePat(node) } } impl From<TupleStructPat> for Pat { + #[inline] fn from(node: TupleStructPat) -> Pat { Pat::TupleStructPat(node) } } impl From<WildcardPat> for Pat { + #[inline] fn from(node: WildcardPat) -> Pat { Pat::WildcardPat(node) } } impl AstNode for Pat { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!( kind, @@ -3942,6 +4915,7 @@ impl AstNode for Pat { | WILDCARD_PAT ) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { let res = match syntax.kind() { BOX_PAT => Pat::BoxPat(BoxPat { syntax }), @@ -3964,6 +4938,7 @@ impl AstNode for Pat { }; Some(res) } + #[inline] fn syntax(&self) -> &SyntaxNode { match self { Pat::BoxPat(it) => &it.syntax, @@ -3986,57 +4961,75 @@ impl AstNode for Pat { } } impl From<ExprStmt> for Stmt { + #[inline] fn from(node: ExprStmt) -> Stmt { Stmt::ExprStmt(node) } } impl From<Item> for Stmt { + #[inline] fn from(node: Item) -> Stmt { Stmt::Item(node) } } impl From<LetStmt> for Stmt { + #[inline] fn from(node: LetStmt) -> Stmt { Stmt::LetStmt(node) } } impl From<ArrayType> for Type { + #[inline] fn from(node: ArrayType) -> Type { Type::ArrayType(node) } } impl From<DynTraitType> for Type { + #[inline] fn from(node: DynTraitType) -> Type { Type::DynTraitType(node) } } impl From<FnPtrType> for Type { + #[inline] fn from(node: FnPtrType) -> Type { Type::FnPtrType(node) } } impl From<ForType> for Type { + #[inline] fn from(node: ForType) -> Type { Type::ForType(node) } } impl From<ImplTraitType> for Type { + #[inline] fn from(node: ImplTraitType) -> Type { Type::ImplTraitType(node) } } impl From<InferType> for Type { + #[inline] fn from(node: InferType) -> Type { Type::InferType(node) } } impl From<MacroType> for Type { + #[inline] fn from(node: MacroType) -> Type { Type::MacroType(node) } } impl From<NeverType> for Type { + #[inline] fn from(node: NeverType) -> Type { Type::NeverType(node) } } impl From<ParenType> for Type { + #[inline] fn from(node: ParenType) -> Type { Type::ParenType(node) } } impl From<PathType> for Type { + #[inline] fn from(node: PathType) -> Type { Type::PathType(node) } } impl From<PtrType> for Type { + #[inline] fn from(node: PtrType) -> Type { Type::PtrType(node) } } impl From<RefType> for Type { + #[inline] fn from(node: RefType) -> Type { Type::RefType(node) } } impl From<SliceType> for Type { + #[inline] fn from(node: SliceType) -> Type { Type::SliceType(node) } } impl From<TupleType> for Type { + #[inline] fn from(node: TupleType) -> Type { Type::TupleType(node) } } impl AstNode for Type { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!( kind, @@ -4056,6 +5049,7 @@ impl AstNode for Type { | TUPLE_TYPE ) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { let res = match syntax.kind() { ARRAY_TYPE => Type::ArrayType(ArrayType { syntax }), @@ -4076,6 +5070,7 @@ impl AstNode for Type { }; Some(res) } + #[inline] fn syntax(&self) -> &SyntaxNode { match self { Type::ArrayType(it) => &it.syntax, @@ -4102,10 +5097,13 @@ impl AnyHasArgList { } } impl AstNode for AnyHasArgList { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, CALL_EXPR | METHOD_CALL_EXPR) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { Self::can_cast(syntax.kind()).then_some(AnyHasArgList { syntax }) } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AnyHasAttrs { @@ -4115,6 +5113,7 @@ impl AnyHasAttrs { } } impl AstNode for AnyHasAttrs { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!( kind, @@ -4192,9 +5191,11 @@ impl AstNode for AnyHasAttrs { | YIELD_EXPR ) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { Self::can_cast(syntax.kind()).then_some(AnyHasAttrs { syntax }) } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AnyHasDocComments { @@ -4204,6 +5205,7 @@ impl AnyHasDocComments { } } impl AstNode for AnyHasDocComments { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!( kind, @@ -4230,9 +5232,29 @@ impl AstNode for AnyHasDocComments { | VARIANT ) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { Self::can_cast(syntax.kind()).then_some(AnyHasDocComments { syntax }) } + #[inline] + fn syntax(&self) -> &SyntaxNode { &self.syntax } +} +impl AnyHasGenericArgs { + #[inline] + pub fn new<T: ast::HasGenericArgs>(node: T) -> AnyHasGenericArgs { + AnyHasGenericArgs { syntax: node.syntax().clone() } + } +} +impl AstNode for AnyHasGenericArgs { + #[inline] + fn can_cast(kind: SyntaxKind) -> bool { + matches!(kind, ASSOC_TYPE_ARG | METHOD_CALL_EXPR | PATH_SEGMENT) + } + #[inline] + fn cast(syntax: SyntaxNode) -> Option<Self> { + Self::can_cast(syntax.kind()).then_some(AnyHasGenericArgs { syntax }) + } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AnyHasGenericParams { @@ -4242,12 +5264,15 @@ impl AnyHasGenericParams { } } impl AstNode for AnyHasGenericParams { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, ENUM | FN | IMPL | STRUCT | TRAIT | TRAIT_ALIAS | TYPE_ALIAS | UNION) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { Self::can_cast(syntax.kind()).then_some(AnyHasGenericParams { syntax }) } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AnyHasLoopBody { @@ -4257,10 +5282,13 @@ impl AnyHasLoopBody { } } impl AstNode for AnyHasLoopBody { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, FOR_EXPR | LOOP_EXPR | WHILE_EXPR) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { Self::can_cast(syntax.kind()).then_some(AnyHasLoopBody { syntax }) } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AnyHasModuleItem { @@ -4270,10 +5298,13 @@ impl AnyHasModuleItem { } } impl AstNode for AnyHasModuleItem { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, ITEM_LIST | MACRO_ITEMS | SOURCE_FILE) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { Self::can_cast(syntax.kind()).then_some(AnyHasModuleItem { syntax }) } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AnyHasName { @@ -4283,6 +5314,7 @@ impl AnyHasName { } } impl AstNode for AnyHasName { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!( kind, @@ -4308,9 +5340,11 @@ impl AstNode for AnyHasName { | VARIANT ) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { Self::can_cast(syntax.kind()).then_some(AnyHasName { syntax }) } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AnyHasTypeBounds { @@ -4320,15 +5354,18 @@ impl AnyHasTypeBounds { } } impl AstNode for AnyHasTypeBounds { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!( kind, ASSOC_TYPE_ARG | LIFETIME_PARAM | TRAIT | TYPE_ALIAS | TYPE_PARAM | WHERE_PRED ) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { Self::can_cast(syntax.kind()).then_some(AnyHasTypeBounds { syntax }) } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl AnyHasVisibility { @@ -4338,6 +5375,7 @@ impl AnyHasVisibility { } } impl AstNode for AnyHasVisibility { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!( kind, @@ -4361,9 +5399,11 @@ impl AstNode for AnyHasVisibility { | VARIANT ) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { Self::can_cast(syntax.kind()).then_some(AnyHasVisibility { syntax }) } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } impl std::fmt::Display for Adt { diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/node_ext.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/node_ext.rs index b0fbe7101c1..911e3d823de 100644 --- a/src/tools/rust-analyzer/crates/syntax/src/ast/node_ext.rs +++ b/src/tools/rust-analyzer/crates/syntax/src/ast/node_ext.rs @@ -10,7 +10,10 @@ use parser::SyntaxKind; use rowan::{GreenNodeData, GreenTokenData}; use crate::{ - ast::{self, support, AstNode, AstToken, HasAttrs, HasGenericParams, HasName, SyntaxNode}, + ast::{ + self, support, AstNode, AstToken, HasAttrs, HasGenericArgs, HasGenericParams, HasName, + SyntaxNode, + }, ted, NodeOrToken, SmolStr, SyntaxElement, SyntaxToken, TokenText, T, }; diff --git a/src/tools/rust-analyzer/crates/syntax/src/ast/traits.rs b/src/tools/rust-analyzer/crates/syntax/src/ast/traits.rs index 16f7356b1e3..152b0cb98c2 100644 --- a/src/tools/rust-analyzer/crates/syntax/src/ast/traits.rs +++ b/src/tools/rust-analyzer/crates/syntax/src/ast/traits.rs @@ -52,6 +52,11 @@ pub trait HasGenericParams: AstNode { support::child(self.syntax()) } } +pub trait HasGenericArgs: AstNode { + fn generic_arg_list(&self) -> Option<ast::GenericArgList> { + support::child(self.syntax()) + } +} pub trait HasTypeBounds: AstNode { fn type_bound_list(&self) -> Option<ast::TypeBoundList> { diff --git a/src/tools/rust-analyzer/xtask/src/codegen/grammar.rs b/src/tools/rust-analyzer/xtask/src/codegen/grammar.rs index 2d492f79f17..45fa2d37c8f 100644 --- a/src/tools/rust-analyzer/xtask/src/codegen/grammar.rs +++ b/src/tools/rust-analyzer/xtask/src/codegen/grammar.rs @@ -122,18 +122,21 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: &AstSrc) -> String { if field.is_many() { quote! { + #[inline] pub fn #method_name(&self) -> AstChildren<#ty> { support::children(&self.syntax) } } } else if let Some(token_kind) = field.token_kind() { quote! { + #[inline] pub fn #method_name(&self) -> Option<#ty> { support::token(&self.syntax, #token_kind) } } } else { quote! { + #[inline] pub fn #method_name(&self) -> Option<#ty> { support::child(&self.syntax) } @@ -156,12 +159,15 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: &AstSrc) -> String { }, quote! { impl AstNode for #name { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { kind == #kind } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None } } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } } }, @@ -190,9 +196,11 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: &AstSrc) -> String { } else { quote! { impl AstNode for #name { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, #(#kinds)|*) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { let res = match syntax.kind() { #( @@ -202,6 +210,7 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: &AstSrc) -> String { }; Some(res) } + #[inline] fn syntax(&self) -> &SyntaxNode { match self { #( @@ -226,6 +235,7 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: &AstSrc) -> String { quote! { #( impl From<#variants> for #name { + #[inline] fn from(node: #variants) -> #name { #name::#variants(node) } @@ -270,12 +280,15 @@ fn generate_nodes(kinds: KindsSrc<'_>, grammar: &AstSrc) -> String { } } impl AstNode for #name { + #[inline] fn can_cast(kind: SyntaxKind) -> bool { matches!(kind, #(#kinds)|*) } + #[inline] fn cast(syntax: SyntaxNode) -> Option<Self> { Self::can_cast(syntax.kind()).then_some(#name { syntax }) } + #[inline] fn syntax(&self) -> &SyntaxNode { &self.syntax } @@ -797,20 +810,21 @@ fn extract_enums(ast: &mut AstSrc) { } } -fn extract_struct_traits(ast: &mut AstSrc) { - let traits: &[(&str, &[&str])] = &[ - ("HasAttrs", &["attrs"]), - ("HasName", &["name"]), - ("HasVisibility", &["visibility"]), - ("HasGenericParams", &["generic_param_list", "where_clause"]), - ("HasTypeBounds", &["type_bound_list", "colon_token"]), - ("HasModuleItem", &["items"]), - ("HasLoopBody", &["label", "loop_body"]), - ("HasArgList", &["arg_list"]), - ]; +const TRAITS: &[(&str, &[&str])] = &[ + ("HasAttrs", &["attrs"]), + ("HasName", &["name"]), + ("HasVisibility", &["visibility"]), + ("HasGenericParams", &["generic_param_list", "where_clause"]), + ("HasGenericArgs", &["generic_arg_list"]), + ("HasTypeBounds", &["type_bound_list", "colon_token"]), + ("HasModuleItem", &["items"]), + ("HasLoopBody", &["label", "loop_body"]), + ("HasArgList", &["arg_list"]), +]; +fn extract_struct_traits(ast: &mut AstSrc) { for node in &mut ast.nodes { - for (name, methods) in traits { + for (name, methods) in TRAITS { extract_struct_trait(node, name, methods); } } |