diff --git a/crates/ra_assists/src/handlers/add_impl.rs b/crates/ra_assists/src/handlers/add_impl.rs index 6622eadb2da..72a201b6d2e 100644 --- a/crates/ra_assists/src/handlers/add_impl.rs +++ b/crates/ra_assists/src/handlers/add_impl.rs @@ -1,5 +1,5 @@ use ra_syntax::{ - ast::{self, AstNode, NameOwner, TypeParamsOwner}, + ast::{self, AstNode, AstToken, NameOwner, TypeParamsOwner}, TextUnit, }; use stdx::{format_to, SepBy}; @@ -42,7 +42,7 @@ pub(crate) fn add_impl(ctx: AssistCtx) -> Option { if let Some(type_params) = type_params { let lifetime_params = type_params .lifetime_params() - .filter_map(|it| it.lifetime_token()) + .filter_map(|it| it.lifetime()) .map(|it| it.text().clone()); let type_params = type_params.type_params().filter_map(|it| it.name()).map(|it| it.text().clone()); diff --git a/crates/ra_assists/src/handlers/add_new.rs b/crates/ra_assists/src/handlers/add_new.rs index 240b19fa378..c10397249fd 100644 --- a/crates/ra_assists/src/handlers/add_new.rs +++ b/crates/ra_assists/src/handlers/add_new.rs @@ -1,7 +1,8 @@ use hir::Adt; use ra_syntax::{ ast::{ - self, AstNode, NameOwner, StructKind, TypeAscriptionOwner, TypeParamsOwner, VisibilityOwner, + self, AstNode, AstToken, NameOwner, StructKind, TypeAscriptionOwner, TypeParamsOwner, + VisibilityOwner, }, TextUnit, T, }; @@ -105,7 +106,7 @@ fn generate_impl_text(strukt: &ast::StructDef, code: &str) -> String { if let Some(type_params) = type_params { let lifetime_params = type_params .lifetime_params() - .filter_map(|it| it.lifetime_token()) + .filter_map(|it| it.lifetime()) .map(|it| it.text().clone()); let type_params = type_params.type_params().filter_map(|it| it.name()).map(|it| it.text().clone()); diff --git a/crates/ra_assists/src/handlers/introduce_variable.rs b/crates/ra_assists/src/handlers/introduce_variable.rs index 1edbdc14c74..8a02f1a32c5 100644 --- a/crates/ra_assists/src/handlers/introduce_variable.rs +++ b/crates/ra_assists/src/handlers/introduce_variable.rs @@ -124,7 +124,7 @@ fn anchor_stmt(expr: ast::Expr) -> Option<(SyntaxNode, bool)> { } } - if ast::Stmt::cast(node.clone()).is_some() { + if ast::Stmt::cast(node.clone().into()).is_some() { return Some((node, false)); } diff --git a/crates/ra_assists/src/handlers/merge_imports.rs b/crates/ra_assists/src/handlers/merge_imports.rs index 5d4b74e567a..f8b3ddb4e18 100644 --- a/crates/ra_assists/src/handlers/merge_imports.rs +++ b/crates/ra_assists/src/handlers/merge_imports.rs @@ -3,7 +3,7 @@ use std::iter::successors; use ra_syntax::{ algo::{neighbor, SyntaxRewriter}, ast::{self, edit::AstNodeEdit, make}, - AstNode, Direction, InsertPosition, SyntaxElement, T, + AstNode, AstToken, Direction, InsertPosition, SyntaxElement, T, }; use crate::{Assist, AssistCtx, AssistId}; @@ -82,7 +82,7 @@ fn try_merge_trees(old: &ast::UseTree, new: &ast::UseTree) -> Option Option { } else { // Unwrap `{ continue; }` let (stmt,) = block.statements().next_tuple()?; - if has_anything_else(stmt.syntax()) { - return None; - } if let ast::Stmt::ExprStmt(expr_stmt) = stmt { + if has_anything_else(expr_stmt.syntax()) { + return None; + } let expr = expr_stmt.expr()?; match expr.syntax().kind() { CONTINUE_EXPR | BREAK_EXPR | RETURN_EXPR => return Some(expr), diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs index 06145e92afc..032037c8cfe 100644 --- a/crates/ra_hir_def/src/body/lower.rs +++ b/crates/ra_hir_def/src/body/lower.rs @@ -497,14 +497,16 @@ impl ExprCollector<'_> { self.collect_block_items(&block); let statements = block .statements() - .map(|s| match s { + .filter_map(|s| match s { ast::Stmt::LetStmt(stmt) => { let pat = self.collect_pat_opt(stmt.pat()); let type_ref = stmt.ascribed_type().map(TypeRef::from_ast); let initializer = stmt.initializer().map(|e| self.collect_expr(e)); - Statement::Let { pat, type_ref, initializer } + Some(Statement::Let { pat, type_ref, initializer }) + } + ast::Stmt::ExprStmt(stmt) => { + Some(Statement::Expr(self.collect_expr_opt(stmt.expr()))) } - ast::Stmt::ExprStmt(stmt) => Statement::Expr(self.collect_expr_opt(stmt.expr())), }) .collect(); let tail = block.expr().map(|e| self.collect_expr(e)); @@ -556,6 +558,7 @@ impl ExprCollector<'_> { let ast_id = self.expander.ast_id(&def); (TraitLoc { container, ast_id }.intern(self.db).into(), def.name()) } + ast::ModuleItem::ExternBlock(_) => continue, // FIXME: collect from extern blocks ast::ModuleItem::ImplDef(_) | ast::ModuleItem::UseItem(_) | ast::ModuleItem::ExternCrateItem(_) diff --git a/crates/ra_hir_def/src/nameres/raw.rs b/crates/ra_hir_def/src/nameres/raw.rs index 8f190e7f917..a9dff3a5d5a 100644 --- a/crates/ra_hir_def/src/nameres/raw.rs +++ b/crates/ra_hir_def/src/nameres/raw.rs @@ -266,6 +266,10 @@ impl RawItemsCollector { self.add_macro(current_module, it); return; } + ast::ModuleItem::ExternBlock(_) => { + // FIXME: add extern block + return; + } }; if let Some(name) = name { let name = name.as_name(); diff --git a/crates/ra_hir_def/src/path/lower.rs b/crates/ra_hir_def/src/path/lower.rs index 4900000fe49..3c13cb2c788 100644 --- a/crates/ra_hir_def/src/path/lower.rs +++ b/crates/ra_hir_def/src/path/lower.rs @@ -28,7 +28,7 @@ pub(super) fn lower_path(mut path: ast::Path, hygiene: &Hygiene) -> Option loop { let segment = path.segment()?; - if segment.has_colon_colon() { + if segment.coloncolon().is_some() { kind = PathKind::Abs; } diff --git a/crates/ra_hir_def/src/path/lower/lower_use.rs b/crates/ra_hir_def/src/path/lower/lower_use.rs index 278d5196e7b..6ec944228cf 100644 --- a/crates/ra_hir_def/src/path/lower/lower_use.rs +++ b/crates/ra_hir_def/src/path/lower/lower_use.rs @@ -34,7 +34,7 @@ pub(crate) fn lower_use_tree( let alias = tree.alias().map(|a| { a.name().map(|it| it.as_name()).map_or(ImportAlias::Underscore, ImportAlias::Alias) }); - let is_glob = tree.has_star(); + let is_glob = tree.star().is_some(); if let Some(ast_path) = tree.path() { // Handle self in a path. // E.g. `use something::{self, <...>}` diff --git a/crates/ra_hir_def/src/visibility.rs b/crates/ra_hir_def/src/visibility.rs index 62513873ef5..1482d3be04d 100644 --- a/crates/ra_hir_def/src/visibility.rs +++ b/crates/ra_hir_def/src/visibility.rs @@ -84,6 +84,10 @@ impl RawVisibility { let path = ModPath { kind: PathKind::Super(1), segments: Vec::new() }; RawVisibility::Module(path) } + ast::VisibilityKind::PubSelf => { + let path = ModPath { kind: PathKind::Plain, segments: Vec::new() }; + RawVisibility::Module(path) + } ast::VisibilityKind::Pub => RawVisibility::Public, } } diff --git a/crates/ra_hir_ty/src/tests.rs b/crates/ra_hir_ty/src/tests.rs index 02f2e5de09f..08723068f8e 100644 --- a/crates/ra_hir_ty/src/tests.rs +++ b/crates/ra_hir_ty/src/tests.rs @@ -23,7 +23,7 @@ use insta::assert_snapshot; use ra_db::{fixture::WithFixture, salsa::Database, FilePosition, SourceDatabase}; use ra_syntax::{ algo, - ast::{self, AstNode}, + ast::{self, AstNode, AstToken}, }; use stdx::format_to; @@ -101,7 +101,7 @@ fn infer_with_mismatches(content: &str, include_mismatches: bool) -> String { let node = src_ptr.value.to_node(&src_ptr.file_syntax(&db)); let (range, text) = if let Some(self_param) = ast::SelfParam::cast(node.clone()) { - (self_param.self_kw_token().text_range(), "self".to_string()) + (self_param.self_kw().unwrap().syntax().text_range(), "self".to_string()) } else { (src_ptr.value.range(), node.text().to_string().replace("\n", " ")) }; @@ -367,7 +367,7 @@ fn no_such_field_with_feature_flag_diagnostics_on_struct_lit() { fn new(foo: u32) -> Self { Self { foo } } - #[cfg(not(feature = "foo"))] + #[cfg(not(feature = "foo"))] fn new(bar: u32) -> Self { Self { bar } } diff --git a/crates/ra_parser/src/grammar.rs b/crates/ra_parser/src/grammar.rs index 58098e8106a..d0530955e0c 100644 --- a/crates/ra_parser/src/grammar.rs +++ b/crates/ra_parser/src/grammar.rs @@ -245,7 +245,7 @@ fn opt_fn_ret_type(p: &mut Parser) -> bool { if p.at(T![->]) { let m = p.start(); p.bump(T![->]); - types::type_(p); + types::type_no_bounds(p); m.complete(p, RET_TYPE); true } else { diff --git a/crates/ra_parser/src/syntax_kind/generated.rs b/crates/ra_parser/src/syntax_kind/generated.rs index 4c16cf1cd9a..004f4e56431 100644 --- a/crates/ra_parser/src/syntax_kind/generated.rs +++ b/crates/ra_parser/src/syntax_kind/generated.rs @@ -105,6 +105,7 @@ pub enum SyntaxKind { DEFAULT_KW, EXISTENTIAL_KW, UNION_KW, + RAW_KW, INT_NUMBER, FLOAT_NUMBER, CHAR, @@ -258,7 +259,7 @@ impl SyntaxKind { | IMPL_KW | IN_KW | LET_KW | LOOP_KW | MACRO_KW | MATCH_KW | MOD_KW | MOVE_KW | MUT_KW | PUB_KW | REF_KW | RETURN_KW | SELF_KW | STATIC_KW | STRUCT_KW | SUPER_KW | TRAIT_KW | TRUE_KW | TRY_KW | TYPE_KW | UNSAFE_KW | USE_KW | WHERE_KW | WHILE_KW - | AUTO_KW | DEFAULT_KW | EXISTENTIAL_KW | UNION_KW => true, + | AUTO_KW | DEFAULT_KW | EXISTENTIAL_KW | UNION_KW | RAW_KW => true, _ => false, } } @@ -651,4 +652,7 @@ macro_rules! T { ( union ) => { $crate::SyntaxKind::UNION_KW }; + ( raw ) => { + $crate::SyntaxKind::RAW_KW + }; } diff --git a/crates/ra_syntax/src/algo.rs b/crates/ra_syntax/src/algo.rs index 8d1098036d4..7f87f421262 100644 --- a/crates/ra_syntax/src/algo.rs +++ b/crates/ra_syntax/src/algo.rs @@ -7,7 +7,7 @@ use std::{ use itertools::Itertools; use ra_text_edit::TextEditBuilder; -use rustc_hash::{FxHashMap, FxHashSet}; +use rustc_hash::FxHashMap; use crate::{ AstNode, Direction, NodeOrToken, SyntaxElement, SyntaxNode, SyntaxNodePtr, SyntaxToken, @@ -72,8 +72,18 @@ pub fn find_covering_element(root: &SyntaxNode, range: TextRange) -> SyntaxEleme } pub fn least_common_ancestor(u: &SyntaxNode, v: &SyntaxNode) -> Option { - let u_ancestors = u.ancestors().collect::>(); - v.ancestors().find(|it| u_ancestors.contains(it)) + if u == v { + return Some(u.clone()); + } + + let u_depth = u.ancestors().count(); + let v_depth = v.ancestors().count(); + let keep = u_depth.min(v_depth); + + let u_candidates = u.ancestors().skip(u_depth - keep); + let v_canidates = v.ancestors().skip(v_depth - keep); + let (res, _) = u_candidates.zip(v_canidates).find(|(x, y)| x == y)?; + Some(res) } pub fn neighbor(me: &T, direction: Direction) -> Option { diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs index ab0f44dd2e0..a42eec91a9c 100644 --- a/crates/ra_syntax/src/ast.rs +++ b/crates/ra_syntax/src/ast.rs @@ -21,7 +21,7 @@ pub use self::{ AttrKind, FieldKind, PathSegmentKind, SelfParamKind, SlicePatComponents, StructKind, TypeBoundKind, VisibilityKind, }, - generated::*, + generated::{nodes::*, tokens::*}, tokens::*, traits::*, }; @@ -64,6 +64,22 @@ pub trait AstToken { } } +mod support { + use super::{AstChildren, AstNode, AstToken, SyntaxNode}; + + pub(super) fn child(parent: &SyntaxNode) -> Option { + parent.children().find_map(N::cast) + } + + pub(super) fn children(parent: &SyntaxNode) -> AstChildren { + AstChildren::new(parent) + } + + pub(super) fn token(parent: &SyntaxNode) -> Option { + parent.children_with_tokens().filter_map(|it| it.into_token()).find_map(T::cast) + } +} + /// An iterator over `SyntaxNode` children of a particular AST type. #[derive(Debug, Clone)] pub struct AstChildren { @@ -271,7 +287,7 @@ where let pred = predicates.next().unwrap(); let mut bounds = pred.type_bound_list().unwrap().bounds(); - assert_eq!("'a", pred.lifetime_token().unwrap().text()); + assert_eq!("'a", pred.lifetime().unwrap().text()); assert_bound("'b", bounds.next()); assert_bound("'c", bounds.next()); diff --git a/crates/ra_syntax/src/ast/edit.rs b/crates/ra_syntax/src/ast/edit.rs index b69cae234cf..d7931099535 100644 --- a/crates/ra_syntax/src/ast/edit.rs +++ b/crates/ra_syntax/src/ast/edit.rs @@ -99,7 +99,7 @@ impl ast::ItemList { None => match self.l_curly() { Some(it) => ( " ".to_string() + &leading_indent(self.syntax()).unwrap_or_default(), - InsertPosition::After(it), + InsertPosition::After(it.syntax().clone().into()), ), None => return self.clone(), }, @@ -109,10 +109,6 @@ impl ast::ItemList { [ws.ws().into(), item.syntax().clone().into()].into(); self.insert_children(position, to_insert) } - - fn l_curly(&self) -> Option { - self.syntax().children_with_tokens().find(|it| it.kind() == T!['{']) - } } impl ast::RecordFieldList { @@ -147,7 +143,7 @@ impl ast::RecordFieldList { macro_rules! after_l_curly { () => {{ let anchor = match self.l_curly() { - Some(it) => it, + Some(it) => it.syntax().clone().into(), None => return self.clone(), }; InsertPosition::After(anchor) @@ -189,24 +185,20 @@ impl ast::RecordFieldList { self.insert_children(position, to_insert) } - - fn l_curly(&self) -> Option { - self.syntax().children_with_tokens().find(|it| it.kind() == T!['{']) - } } impl ast::TypeParam { #[must_use] pub fn remove_bounds(&self) -> ast::TypeParam { - let colon = match self.colon_token() { + let colon = match self.colon() { Some(it) => it, None => return self.clone(), }; let end = match self.type_bound_list() { Some(it) => it.syntax().clone().into(), - None => colon.clone().into(), + None => colon.syntax().clone().into(), }; - self.replace_children(colon.into()..=end, iter::empty()) + self.replace_children(colon.syntax().clone().into()..=end, iter::empty()) } } @@ -305,8 +297,12 @@ impl ast::UseTree { Some(it) => it, None => return self.clone(), }; - let use_tree = - make::use_tree(suffix.clone(), self.use_tree_list(), self.alias(), self.has_star()); + let use_tree = make::use_tree( + suffix.clone(), + self.use_tree_list(), + self.alias(), + self.star().is_some(), + ); let nested = make::use_tree_list(iter::once(use_tree)); return make::use_tree(prefix.clone(), Some(nested), None, false); diff --git a/crates/ra_syntax/src/ast/expr_extensions.rs b/crates/ra_syntax/src/ast/expr_extensions.rs index 8bbd946c071..40c8fca3be3 100644 --- a/crates/ra_syntax/src/ast/expr_extensions.rs +++ b/crates/ra_syntax/src/ast/expr_extensions.rs @@ -52,6 +52,10 @@ impl ast::RefExpr { pub fn is_mut(&self) -> bool { self.syntax().children_with_tokens().any(|n| n.kind() == T![mut]) } + + pub fn raw_token(&self) -> Option { + None // FIXME: implement &raw + } } #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)] diff --git a/crates/ra_syntax/src/ast/extensions.rs b/crates/ra_syntax/src/ast/extensions.rs index bf7d137be7d..33fe60762a3 100644 --- a/crates/ra_syntax/src/ast/extensions.rs +++ b/crates/ra_syntax/src/ast/extensions.rs @@ -4,7 +4,9 @@ use itertools::Itertools; use crate::{ - ast::{self, child_opt, children, AstNode, AttrInput, NameOwner, SyntaxNode}, + ast::{ + self, child_opt, children, support, AstNode, AstToken, AttrInput, NameOwner, SyntaxNode, + }, SmolStr, SyntaxElement, SyntaxKind::*, SyntaxToken, T, @@ -130,13 +132,6 @@ impl ast::PathSegment { }; Some(res) } - - pub fn has_colon_colon(&self) -> bool { - match self.syntax.first_child_or_token().map(|s| s.kind()) { - Some(T![::]) => true, - _ => false, - } - } } impl ast::Path { @@ -154,12 +149,6 @@ impl ast::Module { } } -impl ast::UseTree { - pub fn has_star(&self) -> bool { - self.syntax().children_with_tokens().any(|it| it.kind() == T![*]) - } -} - impl ast::UseTreeList { pub fn parent_use_tree(&self) -> ast::UseTree { self.syntax() @@ -167,20 +156,6 @@ impl ast::UseTreeList { .and_then(ast::UseTree::cast) .expect("UseTreeLists are always nested in UseTrees") } - pub fn l_curly(&self) -> Option { - self.token(T!['{']) - } - - pub fn r_curly(&self) -> Option { - self.token(T!['}']) - } - - fn token(&self, kind: SyntaxKind) -> Option { - self.syntax() - .children_with_tokens() - .filter_map(|it| it.into_token()) - .find(|it| it.kind() == kind) - } } impl ast::ImplDef { @@ -387,24 +362,9 @@ pub enum SelfParamKind { } impl ast::SelfParam { - pub fn self_kw_token(&self) -> SyntaxToken { - self.syntax() - .children_with_tokens() - .filter_map(|it| it.into_token()) - .find(|it| it.kind() == T![self]) - .expect("invalid tree: self param must have self") - } - pub fn kind(&self) -> SelfParamKind { - let borrowed = self.syntax().children_with_tokens().any(|n| n.kind() == T![&]); - if borrowed { - // check for a `mut` coming after the & -- `mut &self` != `&mut self` - if self - .syntax() - .children_with_tokens() - .skip_while(|n| n.kind() != T![&]) - .any(|n| n.kind() == T![mut]) - { + if self.amp().is_some() { + if self.amp_mut_kw().is_some() { SelfParamKind::MutRef } else { SelfParamKind::Ref @@ -413,32 +373,23 @@ impl ast::SelfParam { SelfParamKind::Owned } } -} -impl ast::LifetimeParam { - pub fn lifetime_token(&self) -> Option { + /// the "mut" in "mut self", not the one in "&mut self" + pub fn mut_kw(&self) -> Option { self.syntax() .children_with_tokens() .filter_map(|it| it.into_token()) - .find(|it| it.kind() == LIFETIME) + .take_while(|it| it.kind() != T![&]) + .find_map(ast::MutKw::cast) } -} -impl ast::TypeParam { - pub fn colon_token(&self) -> Option { + /// the "mut" in "&mut self", not the one in "mut self" + pub fn amp_mut_kw(&self) -> Option { self.syntax() .children_with_tokens() .filter_map(|it| it.into_token()) - .find(|it| it.kind() == T![:]) - } -} - -impl ast::WherePred { - pub fn lifetime_token(&self) -> Option { - self.syntax() - .children_with_tokens() - .filter_map(|it| it.into_token()) - .find(|it| it.kind() == LIFETIME) + .skip_while(|it| it.kind() != T![&]) + .find_map(ast::MutKw::cast) } } @@ -449,7 +400,7 @@ pub enum TypeBoundKind { /// for<'a> ... ForType(ast::ForType), /// 'a - Lifetime(ast::SyntaxToken), + Lifetime(ast::Lifetime), } impl ast::TypeBound { @@ -465,21 +416,28 @@ impl ast::TypeBound { } } - fn lifetime(&self) -> Option { - self.syntax() - .children_with_tokens() - .filter_map(|it| it.into_token()) - .find(|it| it.kind() == LIFETIME) + pub fn has_question_mark(&self) -> bool { + self.question().is_some() } - pub fn question_mark_token(&self) -> Option { + pub fn const_question(&self) -> Option { self.syntax() .children_with_tokens() .filter_map(|it| it.into_token()) - .find(|it| it.kind() == T![?]) + .take_while(|it| it.kind() != T![const]) + .find_map(ast::Question::cast) } - pub fn has_question_mark(&self) -> bool { - self.question_mark_token().is_some() + + pub fn question(&self) -> Option { + if self.const_kw().is_some() { + self.syntax() + .children_with_tokens() + .filter_map(|it| it.into_token()) + .skip_while(|it| it.kind() != T![const]) + .find_map(ast::Question::cast) + } else { + support::token(&self.syntax) + } } } @@ -493,6 +451,7 @@ pub enum VisibilityKind { In(ast::Path), PubCrate, PubSuper, + PubSelf, Pub, } @@ -504,6 +463,8 @@ impl ast::Visibility { VisibilityKind::PubCrate } else if self.is_pub_super() { VisibilityKind::PubSuper + } else if self.is_pub_self() { + VisibilityKind::PubSuper } else { VisibilityKind::Pub } @@ -516,6 +477,10 @@ impl ast::Visibility { fn is_pub_super(&self) -> bool { self.syntax().children_with_tokens().any(|it| it.kind() == T![super]) } + + fn is_pub_self(&self) -> bool { + self.syntax().children_with_tokens().any(|it| it.kind() == T![self]) + } } impl ast::MacroCall { @@ -528,3 +493,41 @@ impl ast::MacroCall { } } } + +impl ast::LifetimeParam { + pub fn lifetime_bounds(&self) -> impl Iterator { + self.syntax() + .children_with_tokens() + .filter_map(|it| it.into_token()) + .skip_while(|x| x.kind() != T![:]) + .filter_map(ast::Lifetime::cast) + } +} + +impl ast::RangePat { + pub fn start(&self) -> Option { + self.syntax() + .children_with_tokens() + .take_while(|it| !ast::RangeSeparator::can_cast(it.kind())) + .filter_map(|it| it.into_node()) + .find_map(ast::Pat::cast) + } + + pub fn end(&self) -> Option { + self.syntax() + .children_with_tokens() + .skip_while(|it| !ast::RangeSeparator::can_cast(it.kind())) + .filter_map(|it| it.into_node()) + .find_map(ast::Pat::cast) + } +} + +impl ast::TokenTree { + pub fn left_delimiter(&self) -> Option { + self.syntax().first_child_or_token()?.into_token().and_then(ast::LeftDelimiter::cast) + } + + pub fn right_delimiter(&self) -> Option { + self.syntax().last_child_or_token()?.into_token().and_then(ast::RightDelimiter::cast) + } +} diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs index d2b055b0ad4..f5199e09f21 100644 --- a/crates/ra_syntax/src/ast/generated.rs +++ b/crates/ra_syntax/src/ast/generated.rs @@ -1,7877 +1,6 @@ -//! Generated file, do not edit by hand, see `xtask/src/codegen` +//! This file is actually hand-written, but the submodules are indeed generated. -#[allow(unused_imports)] -use crate::{ - ast::{self, AstChildren, AstNode, AstToken}, - NodeOrToken, SyntaxElement, - SyntaxKind::{self, *}, - SyntaxNode, SyntaxToken, -}; -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Semi { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Semi { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Semi { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - SEMI => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Comma { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Comma { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Comma { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - COMMA => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LParen { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for LParen { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for LParen { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - L_PAREN => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RParen { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for RParen { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for RParen { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - R_PAREN => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LCurly { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for LCurly { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for LCurly { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - L_CURLY => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RCurly { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for RCurly { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for RCurly { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - R_CURLY => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LBrack { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for LBrack { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for LBrack { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - L_BRACK => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RBrack { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for RBrack { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for RBrack { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - R_BRACK => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LAngle { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for LAngle { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for LAngle { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - L_ANGLE => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RAngle { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for RAngle { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for RAngle { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - R_ANGLE => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct At { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for At { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for At { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - AT => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Pound { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Pound { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Pound { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - POUND => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Tilde { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Tilde { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Tilde { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - TILDE => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Question { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Question { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Question { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - QUESTION => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Dollar { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Dollar { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Dollar { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - DOLLAR => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Amp { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Amp { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Amp { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - AMP => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Pipe { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Pipe { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Pipe { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PIPE => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Plus { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Plus { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Plus { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PLUS => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Star { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Star { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Star { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - STAR => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Slash { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Slash { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Slash { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - SLASH => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Caret { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Caret { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Caret { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - CARET => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Percent { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Percent { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Percent { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PERCENT => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Underscore { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Underscore { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Underscore { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - UNDERSCORE => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Dot { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Dot { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Dot { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - DOT => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Dotdot { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Dotdot { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Dotdot { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - DOTDOT => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Dotdotdot { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Dotdotdot { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Dotdotdot { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - DOTDOTDOT => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Dotdoteq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Dotdoteq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Dotdoteq { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - DOTDOTEQ => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Colon { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Colon { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Colon { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - COLON => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Coloncolon { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Coloncolon { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Coloncolon { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - COLONCOLON => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Eq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Eq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Eq { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - EQ => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Eqeq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Eqeq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Eqeq { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - EQEQ => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct FatArrow { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for FatArrow { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for FatArrow { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - FAT_ARROW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Excl { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Excl { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Excl { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - EXCL => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Neq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Neq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Neq { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - NEQ => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Minus { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Minus { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Minus { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - MINUS => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ThinArrow { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for ThinArrow { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for ThinArrow { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - THIN_ARROW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Lteq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Lteq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Lteq { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - LTEQ => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Gteq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Gteq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Gteq { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - GTEQ => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Pluseq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Pluseq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Pluseq { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PLUSEQ => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Minuseq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Minuseq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Minuseq { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - MINUSEQ => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Pipeeq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Pipeeq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Pipeeq { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PIPEEQ => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Ampeq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Ampeq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Ampeq { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - AMPEQ => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Careteq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Careteq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Careteq { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - CARETEQ => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Slasheq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Slasheq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Slasheq { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - SLASHEQ => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Stareq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Stareq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Stareq { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - STAREQ => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Percenteq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Percenteq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Percenteq { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PERCENTEQ => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Ampamp { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Ampamp { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Ampamp { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - AMPAMP => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Pipepipe { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Pipepipe { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Pipepipe { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PIPEPIPE => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Shl { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Shl { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Shl { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - SHL => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Shr { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Shr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Shr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - SHR => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Shleq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Shleq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Shleq { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - SHLEQ => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Shreq { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Shreq { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Shreq { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - SHREQ => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct AsKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for AsKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for AsKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - AS_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct AsyncKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for AsyncKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for AsyncKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - ASYNC_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct AwaitKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for AwaitKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for AwaitKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - AWAIT_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct BoxKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for BoxKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for BoxKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - BOX_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct BreakKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for BreakKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for BreakKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - BREAK_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ConstKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for ConstKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for ConstKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - CONST_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ContinueKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for ContinueKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for ContinueKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - CONTINUE_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct CrateKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for CrateKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for CrateKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - CRATE_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct DynKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for DynKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for DynKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - DYN_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ElseKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for ElseKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for ElseKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - ELSE_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct EnumKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for EnumKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for EnumKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - ENUM_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ExternKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for ExternKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for ExternKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - EXTERN_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct FalseKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for FalseKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for FalseKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - FALSE_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct FnKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for FnKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for FnKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - FN_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ForKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for ForKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for ForKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - FOR_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct IfKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for IfKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for IfKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - IF_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ImplKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for ImplKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for ImplKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - IMPL_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct InKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for InKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for InKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - IN_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LetKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for LetKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for LetKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - LET_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LoopKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for LoopKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for LoopKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - LOOP_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MacroKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for MacroKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for MacroKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - MACRO_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MatchKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for MatchKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for MatchKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - MATCH_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ModKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for ModKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for ModKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - MOD_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MoveKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for MoveKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for MoveKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - MOVE_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MutKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for MutKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for MutKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - MUT_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PubKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for PubKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for PubKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PUB_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RefKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for RefKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for RefKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - REF_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ReturnKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for ReturnKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for ReturnKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - RETURN_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SelfKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for SelfKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for SelfKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - SELF_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct StaticKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for StaticKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for StaticKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - STATIC_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct StructKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for StructKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for StructKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - STRUCT_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SuperKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for SuperKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for SuperKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - SUPER_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TraitKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for TraitKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for TraitKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - TRAIT_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TrueKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for TrueKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for TrueKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - TRUE_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TryKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for TryKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for TryKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - TRY_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TypeKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for TypeKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for TypeKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - TYPE_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct UnsafeKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for UnsafeKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for UnsafeKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - UNSAFE_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct UseKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for UseKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for UseKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - USE_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WhereKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for WhereKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for WhereKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - WHERE_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WhileKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for WhileKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for WhileKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - WHILE_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct AutoKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for AutoKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for AutoKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - AUTO_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct DefaultKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for DefaultKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for DefaultKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - DEFAULT_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ExistentialKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for ExistentialKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for ExistentialKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - EXISTENTIAL_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct UnionKw { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for UnionKw { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for UnionKw { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - UNION_KW => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct IntNumber { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for IntNumber { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for IntNumber { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - INT_NUMBER => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct FloatNumber { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for FloatNumber { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for FloatNumber { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - FLOAT_NUMBER => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Char { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Char { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Char { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - CHAR => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Byte { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Byte { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Byte { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - BYTE => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct String { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for String { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for String { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - STRING => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RawString { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for RawString { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for RawString { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - RAW_STRING => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ByteString { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for ByteString { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for ByteString { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - BYTE_STRING => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RawByteString { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for RawByteString { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for RawByteString { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - RAW_BYTE_STRING => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Error { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Error { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Error { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - ERROR => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Ident { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Ident { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Ident { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - IDENT => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Whitespace { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Whitespace { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Whitespace { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - WHITESPACE => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Lifetime { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Lifetime { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Lifetime { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - LIFETIME => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Comment { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Comment { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Comment { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - COMMENT => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Shebang { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for Shebang { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for Shebang { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - SHEBANG => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LDollar { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for LDollar { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for LDollar { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - L_DOLLAR => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RDollar { - pub(crate) syntax: SyntaxToken, -} -impl std::fmt::Display for RDollar { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(&self.syntax, f) - } -} -impl AstToken for RDollar { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - R_DOLLAR => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxToken { - &self.syntax - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SourceFile { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for SourceFile { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for SourceFile { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - SOURCE_FILE => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::ModuleItemOwner for SourceFile {} -impl ast::FnDefOwner for SourceFile {} -impl SourceFile { - pub fn modules(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct FnDef { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for FnDef { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for FnDef { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - FN_DEF => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::VisibilityOwner for FnDef {} -impl ast::NameOwner for FnDef {} -impl ast::TypeParamsOwner for FnDef {} -impl ast::DocCommentsOwner for FnDef {} -impl ast::AttrsOwner for FnDef {} -impl FnDef { - pub fn param_list(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn ret_type(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn body(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RetType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RetType { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for RetType { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - RET_TYPE => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl RetType { - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct StructDef { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for StructDef { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for StructDef { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - STRUCT_DEF => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::VisibilityOwner for StructDef {} -impl ast::NameOwner for StructDef {} -impl ast::TypeParamsOwner for StructDef {} -impl ast::AttrsOwner for StructDef {} -impl ast::DocCommentsOwner for StructDef {} -impl StructDef {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct UnionDef { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for UnionDef { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for UnionDef { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - UNION_DEF => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::VisibilityOwner for UnionDef {} -impl ast::NameOwner for UnionDef {} -impl ast::TypeParamsOwner for UnionDef {} -impl ast::AttrsOwner for UnionDef {} -impl ast::DocCommentsOwner for UnionDef {} -impl UnionDef { - pub fn record_field_def_list(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordFieldDefList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RecordFieldDefList { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for RecordFieldDefList { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - RECORD_FIELD_DEF_LIST => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl RecordFieldDefList { - pub fn fields(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordFieldDef { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RecordFieldDef { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for RecordFieldDef { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - RECORD_FIELD_DEF => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::VisibilityOwner for RecordFieldDef {} -impl ast::NameOwner for RecordFieldDef {} -impl ast::AttrsOwner for RecordFieldDef {} -impl ast::DocCommentsOwner for RecordFieldDef {} -impl ast::TypeAscriptionOwner for RecordFieldDef {} -impl RecordFieldDef {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TupleFieldDefList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TupleFieldDefList { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for TupleFieldDefList { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - TUPLE_FIELD_DEF_LIST => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl TupleFieldDefList { - pub fn fields(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TupleFieldDef { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TupleFieldDef { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for TupleFieldDef { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - TUPLE_FIELD_DEF => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::VisibilityOwner for TupleFieldDef {} -impl ast::AttrsOwner for TupleFieldDef {} -impl TupleFieldDef { - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct EnumDef { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for EnumDef { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for EnumDef { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - ENUM_DEF => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::VisibilityOwner for EnumDef {} -impl ast::NameOwner for EnumDef {} -impl ast::TypeParamsOwner for EnumDef {} -impl ast::AttrsOwner for EnumDef {} -impl ast::DocCommentsOwner for EnumDef {} -impl EnumDef { - pub fn variant_list(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct EnumVariantList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for EnumVariantList { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for EnumVariantList { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - ENUM_VARIANT_LIST => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl EnumVariantList { - pub fn variants(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct EnumVariant { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for EnumVariant { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for EnumVariant { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - ENUM_VARIANT => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::NameOwner for EnumVariant {} -impl ast::DocCommentsOwner for EnumVariant {} -impl ast::AttrsOwner for EnumVariant {} -impl EnumVariant { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TraitDef { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TraitDef { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for TraitDef { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - TRAIT_DEF => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::VisibilityOwner for TraitDef {} -impl ast::NameOwner for TraitDef {} -impl ast::AttrsOwner for TraitDef {} -impl ast::DocCommentsOwner for TraitDef {} -impl ast::TypeParamsOwner for TraitDef {} -impl ast::TypeBoundsOwner for TraitDef {} -impl TraitDef { - pub fn item_list(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Module { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for Module { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for Module { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - MODULE => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::VisibilityOwner for Module {} -impl ast::NameOwner for Module {} -impl ast::AttrsOwner for Module {} -impl ast::DocCommentsOwner for Module {} -impl Module { - pub fn item_list(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ItemList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ItemList { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for ItemList { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - ITEM_LIST => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::FnDefOwner for ItemList {} -impl ast::ModuleItemOwner for ItemList {} -impl ItemList { - pub fn impl_items(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ConstDef { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ConstDef { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for ConstDef { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - CONST_DEF => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::VisibilityOwner for ConstDef {} -impl ast::NameOwner for ConstDef {} -impl ast::TypeParamsOwner for ConstDef {} -impl ast::AttrsOwner for ConstDef {} -impl ast::DocCommentsOwner for ConstDef {} -impl ast::TypeAscriptionOwner for ConstDef {} -impl ConstDef { - pub fn body(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct StaticDef { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for StaticDef { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for StaticDef { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - STATIC_DEF => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::VisibilityOwner for StaticDef {} -impl ast::NameOwner for StaticDef {} -impl ast::TypeParamsOwner for StaticDef {} -impl ast::AttrsOwner for StaticDef {} -impl ast::DocCommentsOwner for StaticDef {} -impl ast::TypeAscriptionOwner for StaticDef {} -impl StaticDef { - pub fn body(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TypeAliasDef { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TypeAliasDef { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for TypeAliasDef { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - TYPE_ALIAS_DEF => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::VisibilityOwner for TypeAliasDef {} -impl ast::NameOwner for TypeAliasDef {} -impl ast::TypeParamsOwner for TypeAliasDef {} -impl ast::AttrsOwner for TypeAliasDef {} -impl ast::DocCommentsOwner for TypeAliasDef {} -impl ast::TypeBoundsOwner for TypeAliasDef {} -impl TypeAliasDef { - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ImplDef { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ImplDef { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for ImplDef { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - IMPL_DEF => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::TypeParamsOwner for ImplDef {} -impl ast::AttrsOwner for ImplDef {} -impl ImplDef { - pub fn item_list(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ParenType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ParenType { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for ParenType { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PAREN_TYPE => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ParenType { - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TupleType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TupleType { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for TupleType { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - TUPLE_TYPE => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl TupleType { - pub fn fields(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct NeverType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for NeverType { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for NeverType { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - NEVER_TYPE => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl NeverType {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PathType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for PathType { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for PathType { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PATH_TYPE => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl PathType { - pub fn path(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PointerType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for PointerType { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for PointerType { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - POINTER_TYPE => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl PointerType { - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ArrayType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ArrayType { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for ArrayType { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - ARRAY_TYPE => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ArrayType { - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SliceType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for SliceType { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for SliceType { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - SLICE_TYPE => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl SliceType { - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ReferenceType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ReferenceType { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for ReferenceType { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - REFERENCE_TYPE => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ReferenceType { - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PlaceholderType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for PlaceholderType { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for PlaceholderType { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PLACEHOLDER_TYPE => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl PlaceholderType {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct FnPointerType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for FnPointerType { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for FnPointerType { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - FN_POINTER_TYPE => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl FnPointerType { - pub fn param_list(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn ret_type(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ForType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ForType { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for ForType { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - FOR_TYPE => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ForType { - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ImplTraitType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ImplTraitType { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for ImplTraitType { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - IMPL_TRAIT_TYPE => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::TypeBoundsOwner for ImplTraitType {} -impl ImplTraitType {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct DynTraitType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for DynTraitType { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for DynTraitType { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - DYN_TRAIT_TYPE => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::TypeBoundsOwner for DynTraitType {} -impl DynTraitType {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TupleExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TupleExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for TupleExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - TUPLE_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl TupleExpr { - pub fn exprs(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ArrayExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ArrayExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for ArrayExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - ARRAY_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ArrayExpr { - pub fn exprs(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ParenExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ParenExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for ParenExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PAREN_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ParenExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PathExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for PathExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for PathExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PATH_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl PathExpr { - pub fn path(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LambdaExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for LambdaExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for LambdaExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - LAMBDA_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl LambdaExpr { - pub fn param_list(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn ret_type(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn body(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct IfExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for IfExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for IfExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - IF_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl IfExpr { - pub fn condition(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LoopExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for LoopExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for LoopExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - LOOP_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::LoopBodyOwner for LoopExpr {} -impl LoopExpr {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TryBlockExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TryBlockExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for TryBlockExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - TRY_BLOCK_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl TryBlockExpr { - pub fn body(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ForExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ForExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for ForExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - FOR_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::LoopBodyOwner for ForExpr {} -impl ForExpr { - pub fn pat(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn iterable(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WhileExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for WhileExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for WhileExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - WHILE_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::LoopBodyOwner for WhileExpr {} -impl WhileExpr { - pub fn condition(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ContinueExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ContinueExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for ContinueExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - CONTINUE_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ContinueExpr {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct BreakExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for BreakExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for BreakExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - BREAK_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl BreakExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Label { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for Label { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for Label { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - LABEL => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl Label {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct BlockExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for BlockExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for BlockExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - BLOCK_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl BlockExpr { - pub fn block(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ReturnExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ReturnExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for ReturnExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - RETURN_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ReturnExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct CallExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for CallExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for CallExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - CALL_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::ArgListOwner for CallExpr {} -impl CallExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MethodCallExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for MethodCallExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for MethodCallExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - METHOD_CALL_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::ArgListOwner for MethodCallExpr {} -impl MethodCallExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn name_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn type_arg_list(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct IndexExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for IndexExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for IndexExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - INDEX_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl IndexExpr {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct FieldExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for FieldExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for FieldExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - FIELD_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl FieldExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn name_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct AwaitExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for AwaitExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for AwaitExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - AWAIT_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl AwaitExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TryExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TryExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for TryExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - TRY_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl TryExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct CastExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for CastExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for CastExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - CAST_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl CastExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RefExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RefExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for RefExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - REF_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl RefExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PrefixExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for PrefixExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for PrefixExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PREFIX_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl PrefixExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct BoxExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for BoxExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for BoxExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - BOX_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl BoxExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RangeExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RangeExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for RangeExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - RANGE_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl RangeExpr {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct BinExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for BinExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for BinExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - BIN_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl BinExpr {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Literal { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for Literal { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for Literal { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - LITERAL => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl Literal {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MatchExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for MatchExpr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for MatchExpr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - MATCH_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl MatchExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn match_arm_list(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MatchArmList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for MatchArmList { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for MatchArmList { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - MATCH_ARM_LIST => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::AttrsOwner for MatchArmList {} -impl MatchArmList { - pub fn arms(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MatchArm { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for MatchArm { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for MatchArm { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - MATCH_ARM => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::AttrsOwner for MatchArm {} -impl MatchArm { - pub fn pat(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn guard(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MatchGuard { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for MatchGuard { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for MatchGuard { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - MATCH_GUARD => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl MatchGuard { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordLit { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RecordLit { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for RecordLit { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - RECORD_LIT => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl RecordLit { - pub fn path(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn record_field_list(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordFieldList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RecordFieldList { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for RecordFieldList { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - RECORD_FIELD_LIST => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl RecordFieldList { - pub fn fields(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } - pub fn spread(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordField { - pub(crate) syntax: SyntaxNode, -} -impl ast::AttrsOwner for RecordField {} -impl std::fmt::Display for RecordField { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for RecordField { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - RECORD_FIELD => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl RecordField { - pub fn name_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct OrPat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for OrPat { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for OrPat { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - OR_PAT => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl OrPat { - pub fn pats(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ParenPat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ParenPat { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for ParenPat { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PAREN_PAT => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ParenPat { - pub fn pat(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RefPat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RefPat { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for RefPat { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - REF_PAT => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl RefPat { - pub fn pat(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct BoxPat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for BoxPat { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for BoxPat { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - BOX_PAT => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl BoxPat { - pub fn pat(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct BindPat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for BindPat { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for BindPat { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - BIND_PAT => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::NameOwner for BindPat {} -impl BindPat { - pub fn pat(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PlaceholderPat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for PlaceholderPat { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for PlaceholderPat { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PLACEHOLDER_PAT => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl PlaceholderPat {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct DotDotPat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for DotDotPat { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for DotDotPat { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - DOT_DOT_PAT => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl DotDotPat {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PathPat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for PathPat { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for PathPat { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PATH_PAT => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl PathPat { - pub fn path(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SlicePat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for SlicePat { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for SlicePat { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - SLICE_PAT => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl SlicePat { - pub fn args(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RangePat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RangePat { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for RangePat { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - RANGE_PAT => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl RangePat {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LiteralPat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for LiteralPat { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for LiteralPat { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - LITERAL_PAT => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl LiteralPat { - pub fn literal(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MacroPat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for MacroPat { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for MacroPat { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - MACRO_PAT => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl MacroPat { - pub fn macro_call(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordPat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RecordPat { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for RecordPat { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - RECORD_PAT => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl RecordPat { - pub fn record_field_pat_list(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn path(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordFieldPatList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RecordFieldPatList { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for RecordFieldPatList { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - RECORD_FIELD_PAT_LIST => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl RecordFieldPatList { - pub fn record_field_pats(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } - pub fn bind_pats(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordFieldPat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RecordFieldPat { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for RecordFieldPat { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - RECORD_FIELD_PAT => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::NameOwner for RecordFieldPat {} -impl RecordFieldPat { - pub fn pat(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TupleStructPat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TupleStructPat { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for TupleStructPat { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - TUPLE_STRUCT_PAT => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl TupleStructPat { - pub fn path(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn args(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TuplePat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TuplePat { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for TuplePat { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - TUPLE_PAT => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl TuplePat { - pub fn args(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Visibility { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for Visibility { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for Visibility { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - VISIBILITY => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl Visibility {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Name { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for Name { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for Name { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - NAME => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl Name {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct NameRef { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for NameRef { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for NameRef { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - NAME_REF => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl NameRef {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MacroCall { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for MacroCall { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for MacroCall { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - MACRO_CALL => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::NameOwner for MacroCall {} -impl ast::AttrsOwner for MacroCall {} -impl ast::DocCommentsOwner for MacroCall {} -impl MacroCall { - pub fn token_tree(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn path(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Attr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for Attr { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for Attr { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - ATTR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl Attr { - pub fn path(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn input(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TokenTree { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TokenTree { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for TokenTree { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - TOKEN_TREE => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl TokenTree {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TypeParamList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TypeParamList { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for TypeParamList { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - TYPE_PARAM_LIST => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl TypeParamList { - pub fn type_params(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } - pub fn lifetime_params(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TypeParam { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TypeParam { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for TypeParam { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - TYPE_PARAM => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::NameOwner for TypeParam {} -impl ast::AttrsOwner for TypeParam {} -impl ast::TypeBoundsOwner for TypeParam {} -impl TypeParam { - pub fn default_type(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ConstParam { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ConstParam { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for ConstParam { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - CONST_PARAM => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::NameOwner for ConstParam {} -impl ast::AttrsOwner for ConstParam {} -impl ast::TypeAscriptionOwner for ConstParam {} -impl ConstParam { - pub fn default_val(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LifetimeParam { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for LifetimeParam { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for LifetimeParam { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - LIFETIME_PARAM => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::AttrsOwner for LifetimeParam {} -impl LifetimeParam {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TypeBound { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TypeBound { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for TypeBound { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - TYPE_BOUND => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl TypeBound { - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TypeBoundList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TypeBoundList { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for TypeBoundList { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - TYPE_BOUND_LIST => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl TypeBoundList { - pub fn bounds(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WherePred { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for WherePred { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for WherePred { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - WHERE_PRED => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::TypeBoundsOwner for WherePred {} -impl WherePred { - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WhereClause { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for WhereClause { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for WhereClause { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - WHERE_CLAUSE => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl WhereClause { - pub fn predicates(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ExprStmt { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ExprStmt { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for ExprStmt { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - EXPR_STMT => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ExprStmt { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LetStmt { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for LetStmt { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for LetStmt { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - LET_STMT => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::TypeAscriptionOwner for LetStmt {} -impl LetStmt { - pub fn pat(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn initializer(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Condition { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for Condition { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for Condition { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - CONDITION => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl Condition { - pub fn pat(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Block { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for Block { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for Block { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - BLOCK => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::AttrsOwner for Block {} -impl ast::ModuleItemOwner for Block {} -impl Block { - pub fn statements(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ParamList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ParamList { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for ParamList { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PARAM_LIST => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ParamList { - pub fn self_param(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn params(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SelfParam { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for SelfParam { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for SelfParam { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - SELF_PARAM => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::TypeAscriptionOwner for SelfParam {} -impl ast::AttrsOwner for SelfParam {} -impl SelfParam {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Param { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for Param { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for Param { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PARAM => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::TypeAscriptionOwner for Param {} -impl ast::AttrsOwner for Param {} -impl Param { - pub fn pat(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct UseItem { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for UseItem { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for UseItem { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - USE_ITEM => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::AttrsOwner for UseItem {} -impl ast::VisibilityOwner for UseItem {} -impl UseItem { - pub fn use_tree(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct UseTree { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for UseTree { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for UseTree { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - USE_TREE => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl UseTree { - pub fn path(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn use_tree_list(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn alias(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Alias { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for Alias { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for Alias { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - ALIAS => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::NameOwner for Alias {} -impl Alias {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct UseTreeList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for UseTreeList { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for UseTreeList { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - USE_TREE_LIST => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl UseTreeList { - pub fn use_trees(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ExternCrateItem { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ExternCrateItem { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for ExternCrateItem { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - EXTERN_CRATE_ITEM => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::AttrsOwner for ExternCrateItem {} -impl ast::VisibilityOwner for ExternCrateItem {} -impl ExternCrateItem { - pub fn name_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn alias(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ArgList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ArgList { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for ArgList { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - ARG_LIST => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ArgList { - pub fn args(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Path { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for Path { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for Path { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PATH => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl Path { - pub fn segment(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn qualifier(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PathSegment { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for PathSegment { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for PathSegment { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PATH_SEGMENT => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl PathSegment { - pub fn name_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn type_arg_list(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn param_list(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn ret_type(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn path_type(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TypeArgList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TypeArgList { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for TypeArgList { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - TYPE_ARG_LIST => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl TypeArgList { - pub fn type_args(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } - pub fn lifetime_args(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } - pub fn assoc_type_args(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } - pub fn const_arg(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TypeArg { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TypeArg { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for TypeArg { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - TYPE_ARG => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl TypeArg { - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct AssocTypeArg { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for AssocTypeArg { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for AssocTypeArg { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - ASSOC_TYPE_ARG => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl AssocTypeArg { - pub fn name_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LifetimeArg { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for LifetimeArg { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for LifetimeArg { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - LIFETIME_ARG => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl LifetimeArg {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ConstArg { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ConstArg { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for ConstArg { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - CONST_ARG => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ConstArg { - pub fn literal(&self) -> Option { - AstChildren::new(&self.syntax).next() - } - pub fn block_expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MacroItems { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for MacroItems { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for MacroItems { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - MACRO_ITEMS => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ast::ModuleItemOwner for MacroItems {} -impl ast::FnDefOwner for MacroItems {} -impl MacroItems {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MacroStmts { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for MacroStmts { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for MacroStmts { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - MACRO_STMTS => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) - } else { - None - } - } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl MacroStmts { - pub fn statements(&self) -> AstChildren { - AstChildren::new(&self.syntax) - } - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum NominalDef { - StructDef(StructDef), - EnumDef(EnumDef), - UnionDef(UnionDef), -} -impl From for NominalDef { - fn from(node: StructDef) -> NominalDef { - NominalDef::StructDef(node) - } -} -impl From for NominalDef { - fn from(node: EnumDef) -> NominalDef { - NominalDef::EnumDef(node) - } -} -impl From for NominalDef { - fn from(node: UnionDef) -> NominalDef { - NominalDef::UnionDef(node) - } -} -impl std::fmt::Display for NominalDef { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for NominalDef { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - STRUCT_DEF | ENUM_DEF | UNION_DEF => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - let res = match syntax.kind() { - STRUCT_DEF => NominalDef::StructDef(StructDef { syntax }), - ENUM_DEF => NominalDef::EnumDef(EnumDef { syntax }), - UNION_DEF => NominalDef::UnionDef(UnionDef { syntax }), - _ => return None, - }; - Some(res) - } - fn syntax(&self) -> &SyntaxNode { - match self { - NominalDef::StructDef(it) => &it.syntax, - NominalDef::EnumDef(it) => &it.syntax, - NominalDef::UnionDef(it) => &it.syntax, - } - } -} -impl ast::NameOwner for NominalDef {} -impl ast::TypeParamsOwner for NominalDef {} -impl ast::AttrsOwner for NominalDef {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum TypeRef { - ParenType(ParenType), - TupleType(TupleType), - NeverType(NeverType), - PathType(PathType), - PointerType(PointerType), - ArrayType(ArrayType), - SliceType(SliceType), - ReferenceType(ReferenceType), - PlaceholderType(PlaceholderType), - FnPointerType(FnPointerType), - ForType(ForType), - ImplTraitType(ImplTraitType), - DynTraitType(DynTraitType), -} -impl From for TypeRef { - fn from(node: ParenType) -> TypeRef { - TypeRef::ParenType(node) - } -} -impl From for TypeRef { - fn from(node: TupleType) -> TypeRef { - TypeRef::TupleType(node) - } -} -impl From for TypeRef { - fn from(node: NeverType) -> TypeRef { - TypeRef::NeverType(node) - } -} -impl From for TypeRef { - fn from(node: PathType) -> TypeRef { - TypeRef::PathType(node) - } -} -impl From for TypeRef { - fn from(node: PointerType) -> TypeRef { - TypeRef::PointerType(node) - } -} -impl From for TypeRef { - fn from(node: ArrayType) -> TypeRef { - TypeRef::ArrayType(node) - } -} -impl From for TypeRef { - fn from(node: SliceType) -> TypeRef { - TypeRef::SliceType(node) - } -} -impl From for TypeRef { - fn from(node: ReferenceType) -> TypeRef { - TypeRef::ReferenceType(node) - } -} -impl From for TypeRef { - fn from(node: PlaceholderType) -> TypeRef { - TypeRef::PlaceholderType(node) - } -} -impl From for TypeRef { - fn from(node: FnPointerType) -> TypeRef { - TypeRef::FnPointerType(node) - } -} -impl From for TypeRef { - fn from(node: ForType) -> TypeRef { - TypeRef::ForType(node) - } -} -impl From for TypeRef { - fn from(node: ImplTraitType) -> TypeRef { - TypeRef::ImplTraitType(node) - } -} -impl From for TypeRef { - fn from(node: DynTraitType) -> TypeRef { - TypeRef::DynTraitType(node) - } -} -impl std::fmt::Display for TypeRef { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for TypeRef { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PAREN_TYPE | TUPLE_TYPE | NEVER_TYPE | PATH_TYPE | POINTER_TYPE | ARRAY_TYPE - | SLICE_TYPE | REFERENCE_TYPE | PLACEHOLDER_TYPE | FN_POINTER_TYPE | FOR_TYPE - | IMPL_TRAIT_TYPE | DYN_TRAIT_TYPE => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - let res = match syntax.kind() { - PAREN_TYPE => TypeRef::ParenType(ParenType { syntax }), - TUPLE_TYPE => TypeRef::TupleType(TupleType { syntax }), - NEVER_TYPE => TypeRef::NeverType(NeverType { syntax }), - PATH_TYPE => TypeRef::PathType(PathType { syntax }), - POINTER_TYPE => TypeRef::PointerType(PointerType { syntax }), - ARRAY_TYPE => TypeRef::ArrayType(ArrayType { syntax }), - SLICE_TYPE => TypeRef::SliceType(SliceType { syntax }), - REFERENCE_TYPE => TypeRef::ReferenceType(ReferenceType { syntax }), - PLACEHOLDER_TYPE => TypeRef::PlaceholderType(PlaceholderType { syntax }), - FN_POINTER_TYPE => TypeRef::FnPointerType(FnPointerType { syntax }), - FOR_TYPE => TypeRef::ForType(ForType { syntax }), - IMPL_TRAIT_TYPE => TypeRef::ImplTraitType(ImplTraitType { syntax }), - DYN_TRAIT_TYPE => TypeRef::DynTraitType(DynTraitType { syntax }), - _ => return None, - }; - Some(res) - } - fn syntax(&self) -> &SyntaxNode { - match self { - TypeRef::ParenType(it) => &it.syntax, - TypeRef::TupleType(it) => &it.syntax, - TypeRef::NeverType(it) => &it.syntax, - TypeRef::PathType(it) => &it.syntax, - TypeRef::PointerType(it) => &it.syntax, - TypeRef::ArrayType(it) => &it.syntax, - TypeRef::SliceType(it) => &it.syntax, - TypeRef::ReferenceType(it) => &it.syntax, - TypeRef::PlaceholderType(it) => &it.syntax, - TypeRef::FnPointerType(it) => &it.syntax, - TypeRef::ForType(it) => &it.syntax, - TypeRef::ImplTraitType(it) => &it.syntax, - TypeRef::DynTraitType(it) => &it.syntax, - } - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum ModuleItem { - StructDef(StructDef), - UnionDef(UnionDef), - EnumDef(EnumDef), - FnDef(FnDef), - TraitDef(TraitDef), - TypeAliasDef(TypeAliasDef), - ImplDef(ImplDef), - UseItem(UseItem), - ExternCrateItem(ExternCrateItem), - ConstDef(ConstDef), - StaticDef(StaticDef), - Module(Module), - MacroCall(MacroCall), -} -impl From for ModuleItem { - fn from(node: StructDef) -> ModuleItem { - ModuleItem::StructDef(node) - } -} -impl From for ModuleItem { - fn from(node: UnionDef) -> ModuleItem { - ModuleItem::UnionDef(node) - } -} -impl From for ModuleItem { - fn from(node: EnumDef) -> ModuleItem { - ModuleItem::EnumDef(node) - } -} -impl From for ModuleItem { - fn from(node: FnDef) -> ModuleItem { - ModuleItem::FnDef(node) - } -} -impl From for ModuleItem { - fn from(node: TraitDef) -> ModuleItem { - ModuleItem::TraitDef(node) - } -} -impl From for ModuleItem { - fn from(node: TypeAliasDef) -> ModuleItem { - ModuleItem::TypeAliasDef(node) - } -} -impl From for ModuleItem { - fn from(node: ImplDef) -> ModuleItem { - ModuleItem::ImplDef(node) - } -} -impl From for ModuleItem { - fn from(node: UseItem) -> ModuleItem { - ModuleItem::UseItem(node) - } -} -impl From for ModuleItem { - fn from(node: ExternCrateItem) -> ModuleItem { - ModuleItem::ExternCrateItem(node) - } -} -impl From for ModuleItem { - fn from(node: ConstDef) -> ModuleItem { - ModuleItem::ConstDef(node) - } -} -impl From for ModuleItem { - fn from(node: StaticDef) -> ModuleItem { - ModuleItem::StaticDef(node) - } -} -impl From for ModuleItem { - fn from(node: Module) -> ModuleItem { - ModuleItem::Module(node) - } -} -impl From for ModuleItem { - fn from(node: MacroCall) -> ModuleItem { - ModuleItem::MacroCall(node) - } -} -impl std::fmt::Display for ModuleItem { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for ModuleItem { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - STRUCT_DEF | UNION_DEF | ENUM_DEF | FN_DEF | TRAIT_DEF | TYPE_ALIAS_DEF | IMPL_DEF - | USE_ITEM | EXTERN_CRATE_ITEM | CONST_DEF | STATIC_DEF | MODULE | MACRO_CALL => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - let res = match syntax.kind() { - STRUCT_DEF => ModuleItem::StructDef(StructDef { syntax }), - UNION_DEF => ModuleItem::UnionDef(UnionDef { syntax }), - ENUM_DEF => ModuleItem::EnumDef(EnumDef { syntax }), - FN_DEF => ModuleItem::FnDef(FnDef { syntax }), - TRAIT_DEF => ModuleItem::TraitDef(TraitDef { syntax }), - TYPE_ALIAS_DEF => ModuleItem::TypeAliasDef(TypeAliasDef { syntax }), - IMPL_DEF => ModuleItem::ImplDef(ImplDef { syntax }), - USE_ITEM => ModuleItem::UseItem(UseItem { syntax }), - EXTERN_CRATE_ITEM => ModuleItem::ExternCrateItem(ExternCrateItem { syntax }), - CONST_DEF => ModuleItem::ConstDef(ConstDef { syntax }), - STATIC_DEF => ModuleItem::StaticDef(StaticDef { syntax }), - MODULE => ModuleItem::Module(Module { syntax }), - MACRO_CALL => ModuleItem::MacroCall(MacroCall { syntax }), - _ => return None, - }; - Some(res) - } - fn syntax(&self) -> &SyntaxNode { - match self { - ModuleItem::StructDef(it) => &it.syntax, - ModuleItem::UnionDef(it) => &it.syntax, - ModuleItem::EnumDef(it) => &it.syntax, - ModuleItem::FnDef(it) => &it.syntax, - ModuleItem::TraitDef(it) => &it.syntax, - ModuleItem::TypeAliasDef(it) => &it.syntax, - ModuleItem::ImplDef(it) => &it.syntax, - ModuleItem::UseItem(it) => &it.syntax, - ModuleItem::ExternCrateItem(it) => &it.syntax, - ModuleItem::ConstDef(it) => &it.syntax, - ModuleItem::StaticDef(it) => &it.syntax, - ModuleItem::Module(it) => &it.syntax, - ModuleItem::MacroCall(it) => &it.syntax, - } - } -} -impl ast::AttrsOwner for ModuleItem {} -impl ast::VisibilityOwner for ModuleItem {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum ImplItem { - FnDef(FnDef), - TypeAliasDef(TypeAliasDef), - ConstDef(ConstDef), -} -impl From for ImplItem { - fn from(node: FnDef) -> ImplItem { - ImplItem::FnDef(node) - } -} -impl From for ImplItem { - fn from(node: TypeAliasDef) -> ImplItem { - ImplItem::TypeAliasDef(node) - } -} -impl From for ImplItem { - fn from(node: ConstDef) -> ImplItem { - ImplItem::ConstDef(node) - } -} -impl std::fmt::Display for ImplItem { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstNode for ImplItem { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - FN_DEF | TYPE_ALIAS_DEF | CONST_DEF => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - let res = match syntax.kind() { - FN_DEF => ImplItem::FnDef(FnDef { syntax }), - TYPE_ALIAS_DEF => ImplItem::TypeAliasDef(TypeAliasDef { syntax }), - CONST_DEF => ImplItem::ConstDef(ConstDef { syntax }), - _ => return None, - }; - Some(res) - } - fn syntax(&self) -> &SyntaxNode { - match self { - ImplItem::FnDef(it) => &it.syntax, - ImplItem::TypeAliasDef(it) => &it.syntax, - ImplItem::ConstDef(it) => &it.syntax, - } - } -} -impl ast::AttrsOwner for ImplItem {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum Expr { - TupleExpr(TupleExpr), - ArrayExpr(ArrayExpr), - ParenExpr(ParenExpr), - PathExpr(PathExpr), - LambdaExpr(LambdaExpr), - IfExpr(IfExpr), - LoopExpr(LoopExpr), - ForExpr(ForExpr), - WhileExpr(WhileExpr), - ContinueExpr(ContinueExpr), - BreakExpr(BreakExpr), - Label(Label), - BlockExpr(BlockExpr), - ReturnExpr(ReturnExpr), - MatchExpr(MatchExpr), - RecordLit(RecordLit), - CallExpr(CallExpr), - IndexExpr(IndexExpr), - MethodCallExpr(MethodCallExpr), - FieldExpr(FieldExpr), - AwaitExpr(AwaitExpr), - TryExpr(TryExpr), - TryBlockExpr(TryBlockExpr), - CastExpr(CastExpr), - RefExpr(RefExpr), - PrefixExpr(PrefixExpr), - RangeExpr(RangeExpr), - BinExpr(BinExpr), - Literal(Literal), - MacroCall(MacroCall), - BoxExpr(BoxExpr), -} -impl From for Expr { - fn from(node: TupleExpr) -> Expr { - Expr::TupleExpr(node) - } -} -impl From for Expr { - fn from(node: ArrayExpr) -> Expr { - Expr::ArrayExpr(node) - } -} -impl From for Expr { - fn from(node: ParenExpr) -> Expr { - Expr::ParenExpr(node) - } -} -impl From for Expr { - fn from(node: PathExpr) -> Expr { - Expr::PathExpr(node) - } -} -impl From for Expr { - fn from(node: LambdaExpr) -> Expr { - Expr::LambdaExpr(node) - } -} -impl From for Expr { - fn from(node: IfExpr) -> Expr { - Expr::IfExpr(node) - } -} -impl From for Expr { - fn from(node: LoopExpr) -> Expr { - Expr::LoopExpr(node) - } -} -impl From for Expr { - fn from(node: ForExpr) -> Expr { - Expr::ForExpr(node) - } -} -impl From for Expr { - fn from(node: WhileExpr) -> Expr { - Expr::WhileExpr(node) - } -} -impl From for Expr { - fn from(node: ContinueExpr) -> Expr { - Expr::ContinueExpr(node) - } -} -impl From for Expr { - fn from(node: BreakExpr) -> Expr { - Expr::BreakExpr(node) - } -} -impl From