diff --git a/crates/ra_assists/src/handlers/add_impl.rs b/crates/ra_assists/src/handlers/add_impl.rs index 6622eadb2da1..72a201b6d2e6 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 240b19fa378c..c10397249fd1 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 1edbdc14c74d..9963f884bb1d 100644 --- a/crates/ra_assists/src/handlers/introduce_variable.rs +++ b/crates/ra_assists/src/handlers/introduce_variable.rs @@ -1,5 +1,5 @@ use ra_syntax::{ - ast::{self, AstNode}, + ast::{self, AstElement, AstNode}, SyntaxKind::{ BLOCK_EXPR, BREAK_EXPR, COMMENT, LAMBDA_EXPR, LOOP_EXPR, MATCH_ARM, PATH_EXPR, RETURN_EXPR, WHITESPACE, @@ -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_element(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 5d4b74e567a1..f8b3ddb4e18f 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 e8443dde81fa..6ab6599439f2 100644 --- a/crates/ra_hir_def/src/body/lower.rs +++ b/crates/ra_hir_def/src/body/lower.rs @@ -501,14 +501,17 @@ 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) => Statement::Expr(self.collect_expr_opt(stmt.expr())), + ast::Stmt::ExprStmt(stmt) => { + Some(Statement::Expr(self.collect_expr_opt(stmt.expr()))) + } + ast::Stmt::ModuleItem(_) => None, }) .collect(); let tail = block.expr().map(|e| self.collect_expr(e)); @@ -560,6 +563,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(_) @@ -684,6 +688,7 @@ impl ExprCollector<'_> { ast::Pat::BoxPat(_) => Pat::Missing, ast::Pat::LiteralPat(_) => Pat::Missing, ast::Pat::RangePat(_) => Pat::Missing, + ast::Pat::MacroCall(_) => Pat::Missing, }; let ptr = AstPtr::new(&pat); self.alloc_pat(pattern, Either::Left(ptr)) diff --git a/crates/ra_hir_def/src/nameres/raw.rs b/crates/ra_hir_def/src/nameres/raw.rs index 8f190e7f9173..a9dff3a5d5a7 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 4900000fe49d..3c13cb2c7881 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 278d5196e7bc..6ec944228cf6 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 62513873ef50..1482d3be04da 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 027e5a8f88a0..73b9455e26fa 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", " ")) }; diff --git a/crates/ra_parser/src/grammar.rs b/crates/ra_parser/src/grammar.rs index 58098e8106aa..d0530955e0c4 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/lib.rs b/crates/ra_parser/src/lib.rs index 652492c1ed96..b7fbff35ad44 100644 --- a/crates/ra_parser/src/lib.rs +++ b/crates/ra_parser/src/lib.rs @@ -12,6 +12,8 @@ //! //! Tests for this crate live in `ra_syntax` crate. +#![allow(elided_lifetimes_in_paths)] + #[macro_use] mod token_set; #[macro_use] diff --git a/crates/ra_parser/src/syntax_kind/generated.rs b/crates/ra_parser/src/syntax_kind/generated.rs index dfc30d727831..2ecdba986de5 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, @@ -257,7 +258,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, } } @@ -650,4 +651,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 191123c8ed9e..8d1098036d40 100644 --- a/crates/ra_syntax/src/algo.rs +++ b/crates/ra_syntax/src/algo.rs @@ -316,7 +316,7 @@ impl<'a> SyntaxRewriter<'a> { } } -impl<'a> ops::AddAssign for SyntaxRewriter<'_> { +impl ops::AddAssign for SyntaxRewriter<'_> { fn add_assign(&mut self, rhs: SyntaxRewriter) { assert!(rhs.f.is_none()); self.replacements.extend(rhs.replacements) diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs index 26fafb469a96..5ee289e9ca98 100644 --- a/crates/ra_syntax/src/ast.rs +++ b/crates/ra_syntax/src/ast.rs @@ -11,7 +11,10 @@ pub mod make; use std::marker::PhantomData; use crate::{ - syntax_node::{SyntaxNode, SyntaxNodeChildren, SyntaxToken}, + syntax_node::{ + NodeOrToken, SyntaxElement, SyntaxElementChildren, SyntaxNode, SyntaxNodeChildren, + SyntaxToken, + }, SmolStr, SyntaxKind, }; @@ -30,16 +33,24 @@ pub use self::{ /// conversion itself has zero runtime cost: ast and syntax nodes have exactly /// the same representation: a pointer to the tree root and a pointer to the /// node itself. -pub trait AstNode: std::fmt::Display { +pub trait AstNode: AstElement { fn can_cast(kind: SyntaxKind) -> bool where Self: Sized; - fn cast(syntax: SyntaxNode) -> Option + fn cast_or_return(syntax: SyntaxNode) -> Result where Self: Sized; + fn cast(syntax: SyntaxNode) -> Option + where + Self: Sized, + { + ::cast_or_return(syntax).ok() + } + fn syntax(&self) -> &SyntaxNode; + fn into_syntax(self) -> SyntaxNode; } #[test] @@ -48,16 +59,51 @@ fn assert_ast_is_object_safe() { } /// Like `AstNode`, but wraps tokens rather than interior nodes. -pub trait AstToken { - fn cast(token: SyntaxToken) -> Option +pub trait AstToken: AstElement { + fn can_cast(token: SyntaxKind) -> bool where Self: Sized; + + fn cast_or_return(syntax: SyntaxToken) -> Result + where + Self: Sized; + + fn cast(syntax: SyntaxToken) -> Option + where + Self: Sized, + { + ::cast_or_return(syntax).ok() + } + fn syntax(&self) -> &SyntaxToken; + fn into_syntax(self) -> SyntaxToken; + fn text(&self) -> &SmolStr { self.syntax().text() } } +/// Like `AstNode`, but wraps either nodes or tokens rather than interior nodes. +pub trait AstElement: std::fmt::Display { + fn can_cast_element(kind: SyntaxKind) -> bool + where + Self: Sized; + + fn cast_or_return_element(syntax: SyntaxElement) -> Result + where + Self: Sized; + + fn cast_element(syntax: SyntaxElement) -> Option + where + Self: Sized, + { + ::cast_or_return_element(syntax).ok() + } + + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken>; + fn into_syntax_element(self) -> SyntaxElement; +} + /// An iterator over `SyntaxNode` children of a particular AST type. #[derive(Debug, Clone)] pub struct AstChildren { @@ -86,6 +132,64 @@ fn children(parent: &P) -> AstChildren { AstChildren::new(parent.syntax()) } +/// An iterator over `SyntaxToken` children of a particular AST type. +#[derive(Debug, Clone)] +pub struct AstChildTokens { + inner: SyntaxElementChildren, + ph: PhantomData, +} + +impl AstChildTokens { + fn new(parent: &SyntaxNode) -> Self { + AstChildTokens { inner: parent.children_with_tokens(), ph: PhantomData } + } +} + +impl Iterator for AstChildTokens { + type Item = N; + fn next(&mut self) -> Option { + self.inner.by_ref().filter_map(|x| x.into_token()).find_map(N::cast) + } +} + +fn child_token_opt(parent: &P) -> Option { + child_tokens(parent).next() +} + +fn child_tokens(parent: &P) -> AstChildTokens { + AstChildTokens::new(parent.syntax()) +} + +/// An iterator over `SyntaxNode` children of a particular AST type. +#[derive(Debug, Clone)] +pub struct AstChildElements { + inner: SyntaxElementChildren, + ph: PhantomData, +} + +impl AstChildElements { + fn new(parent: &SyntaxNode) -> Self { + AstChildElements { inner: parent.children_with_tokens(), ph: PhantomData } + } +} + +impl Iterator for AstChildElements { + type Item = N; + fn next(&mut self) -> Option { + self.inner.by_ref().find_map(N::cast_element) + } +} + +#[allow(dead_code)] +fn child_element_opt(parent: &P) -> Option { + child_elements(parent).next() +} + +#[allow(dead_code)] +fn child_elements(parent: &P) -> AstChildElements { + AstChildElements::new(parent.syntax()) +} + #[test] fn test_doc_comment_none() { let file = SourceFile::parse( @@ -265,7 +369,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 3d023f1891ba..7aba841bd1c6 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 77cceb382536..6eb2be2a5dd3 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 392731dac220..93b5b0fecc1a 100644 --- a/crates/ra_syntax/src/ast/extensions.rs +++ b/crates/ra_syntax/src/ast/extensions.rs @@ -4,7 +4,10 @@ use itertools::Itertools; use crate::{ - ast::{self, child_opt, children, AstNode, AttrInput, NameOwner, SyntaxNode}, + ast::{ + self, child_opt, child_token_opt, children, AstElement, AstNode, AstToken, AttrInput, + NameOwner, SyntaxNode, + }, SmolStr, SyntaxElement, SyntaxKind::*, SyntaxToken, T, @@ -130,13 +133,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 +150,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 +157,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 { @@ -384,24 +360,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 @@ -410,32 +371,23 @@ impl ast::SelfParam { SelfParamKind::Owned } } -} - -impl ast::LifetimeParam { - pub fn lifetime_token(&self) -> Option { - self.syntax() - .children_with_tokens() - .filter_map(|it| it.into_token()) - .find(|it| it.kind() == LIFETIME) - } -} -impl ast::TypeParam { - pub fn colon_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() == T![:]) + .take_while(|it| it.kind() != T![&]) + .find_map(ast::MutKw::cast) } -} -impl ast::WherePred { - pub fn lifetime_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() == LIFETIME) + .skip_while(|it| it.kind() != T![&]) + .find_map(ast::MutKw::cast) } } @@ -446,7 +398,7 @@ pub enum TypeBoundKind { /// for<'a> ... ForType(ast::ForType), /// 'a - Lifetime(ast::SyntaxToken), + Lifetime(ast::Lifetime), } impl ast::TypeBound { @@ -462,21 +414,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 { + child_token_opt(self) + } } } @@ -490,6 +449,7 @@ pub enum VisibilityKind { In(ast::Path), PubCrate, PubSuper, + PubSelf, Pub, } @@ -501,6 +461,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 } @@ -513,6 +475,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 { @@ -525,3 +491,65 @@ 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_element(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_element(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().and_then(ast::LeftDelimiter::cast_element) + } + + pub fn right_delimiter(&self) -> Option { + self.syntax().last_child_or_token().and_then(ast::RightDelimiter::cast_element) + } +} + +impl ast::Condition { + pub fn pat(&self) -> Option { + if self.eq().is_some() { + self.syntax() + .children_with_tokens() + .take_while(|x| x.kind() != T![=]) + .find_map(ast::Pat::cast_element) + } else { + None + } + } + + pub fn expr(&self) -> Option { + if self.eq().is_some() { + self.syntax() + .children_with_tokens() + .skip_while(|x| x.kind() != T![=]) + .find_map(ast::Expr::cast_element) + } else { + child_opt(self) + } + } +} diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs index 7204ca5b1724..84d0c84d0844 100644 --- a/crates/ra_syntax/src/ast/generated.rs +++ b/crates/ra_syntax/src/ast/generated.rs @@ -1,4810 +1,16721 @@ //! Generated file, do not edit by hand, see `xtask/src/codegen` +#[allow(unused_imports)] use crate::{ - ast::{self, AstChildren, AstNode}, + ast::{self, AstChildElements, AstChildTokens, AstChildren, AstElement, AstNode, AstToken}, + NodeOrToken, SyntaxElement, SyntaxKind::{self, *}, - SyntaxNode, + SyntaxNode, SyntaxToken, }; #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SourceFile { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for SourceFile { +pub struct Semi(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 AstNode for SourceFile { +impl AstToken for Semi { fn can_cast(kind: SyntaxKind) -> bool { match kind { - SOURCE_FILE => true, + SEMI => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl ast::ModuleItemOwner for SourceFile {} -impl ast::FnDefOwner for SourceFile {} -impl SourceFile { - pub fn modules(&self) -> AstChildren { - AstChildren::new(&self.syntax) +impl AstElement for Semi { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + SEMI => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct FnDef { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for FnDef { +pub struct Comma(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 AstNode for FnDef { +impl AstToken for Comma { fn can_cast(kind: SyntaxKind) -> bool { match kind { - FN_DEF => true, + COMMA => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -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() +impl AstElement for Comma { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + COMMA => true, + _ => false, + } } - pub fn ret_type(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } } - pub fn body(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RetType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RetType { +pub struct LParen(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 AstNode for RetType { +impl AstToken for LParen { fn can_cast(kind: SyntaxKind) -> bool { match kind { - RET_TYPE => true, + L_PAREN => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl RetType { - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for LParen { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + L_PAREN => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct StructDef { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for StructDef { +pub struct RParen(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 AstNode for StructDef { +impl AstToken for RParen { fn can_cast(kind: SyntaxKind) -> bool { match kind { - STRUCT_DEF => true, + R_PAREN => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for UnionDef { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for RParen { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - UNION_DEF => true, + R_PAREN => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) } -} -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() + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordFieldDefList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RecordFieldDefList { +pub struct LCurly(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 AstNode for RecordFieldDefList { +impl AstToken for LCurly { fn can_cast(kind: SyntaxKind) -> bool { match kind { - RECORD_FIELD_DEF_LIST => true, + L_CURLY => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl RecordFieldDefList { - pub fn fields(&self) -> AstChildren { - AstChildren::new(&self.syntax) +impl AstElement for LCurly { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + L_CURLY => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordFieldDef { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RecordFieldDef { +pub struct RCurly(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 AstNode for RecordFieldDef { +impl AstToken for RCurly { fn can_cast(kind: SyntaxKind) -> bool { match kind { - RECORD_FIELD_DEF => true, + R_CURLY => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for TupleFieldDefList { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for RCurly { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - TUPLE_FIELD_DEF_LIST => true, + R_CURLY => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) } -} -impl TupleFieldDefList { - pub fn fields(&self) -> AstChildren { - AstChildren::new(&self.syntax) + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TupleFieldDef { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TupleFieldDef { +pub struct LBrack(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 AstNode for TupleFieldDef { +impl AstToken for LBrack { fn can_cast(kind: SyntaxKind) -> bool { match kind { - TUPLE_FIELD_DEF => true, + L_BRACK => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - 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() + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -#[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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for EnumDef { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for LBrack { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - ENUM_DEF => true, + L_BRACK => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) } -} -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() + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct EnumVariantList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for EnumVariantList { +pub struct RBrack(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 AstNode for EnumVariantList { +impl AstToken for RBrack { fn can_cast(kind: SyntaxKind) -> bool { match kind { - ENUM_VARIANT_LIST => true, + R_BRACK => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl EnumVariantList { - pub fn variants(&self) -> AstChildren { - AstChildren::new(&self.syntax) +impl AstElement for RBrack { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + R_BRACK => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct EnumVariant { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for EnumVariant { +pub struct LAngle(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 AstNode for EnumVariant { +impl AstToken for LAngle { fn can_cast(kind: SyntaxKind) -> bool { match kind { - ENUM_VARIANT => true, + L_ANGLE => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -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() +impl AstElement for LAngle { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + L_ANGLE => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TraitDef { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TraitDef { +pub struct RAngle(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 AstNode for TraitDef { +impl AstToken for RAngle { fn can_cast(kind: SyntaxKind) -> bool { match kind { - TRAIT_DEF => true, + R_ANGLE => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -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() +impl AstElement for RAngle { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + R_ANGLE => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Module { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for Module { +pub struct At(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 AstNode for Module { +impl AstToken for At { fn can_cast(kind: SyntaxKind) -> bool { match kind { - MODULE => true, + AT => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -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() +impl AstElement for At { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + AT => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ItemList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ItemList { +pub struct Pound(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 AstNode for ItemList { +impl AstToken for Pound { fn can_cast(kind: SyntaxKind) -> bool { match kind { - ITEM_LIST => true, + POUND => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - 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) + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -#[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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for ConstDef { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for Pound { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - CONST_DEF => true, + POUND => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) } -} -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() + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct StaticDef { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for StaticDef { +pub struct Tilde(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 AstNode for StaticDef { +impl AstToken for Tilde { fn can_cast(kind: SyntaxKind) -> bool { match kind { - STATIC_DEF => true, + TILDE => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - 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() + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -#[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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for TypeAliasDef { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for Tilde { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - TYPE_ALIAS_DEF => true, + TILDE => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) } -} -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() + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ImplDef { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ImplDef { +pub struct Question(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 AstNode for ImplDef { +impl AstToken for Question { fn can_cast(kind: SyntaxKind) -> bool { match kind { - IMPL_DEF => true, + QUESTION => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl ast::TypeParamsOwner for ImplDef {} -impl ast::AttrsOwner for ImplDef {} -impl ImplDef { - pub fn item_list(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Question { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + QUESTION => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ParenType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ParenType { +pub struct Dollar(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 AstNode for ParenType { +impl AstToken for Dollar { fn can_cast(kind: SyntaxKind) -> bool { match kind { - PAREN_TYPE => true, + DOLLAR => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl ParenType { - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Dollar { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + DOLLAR => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TupleType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TupleType { +pub struct Amp(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 AstNode for TupleType { +impl AstToken for Amp { fn can_cast(kind: SyntaxKind) -> bool { match kind { - TUPLE_TYPE => true, + AMP => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl TupleType { - pub fn fields(&self) -> AstChildren { - AstChildren::new(&self.syntax) +impl AstElement for Amp { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + AMP => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct NeverType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for NeverType { +pub struct Pipe(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 AstNode for NeverType { +impl AstToken for Pipe { fn can_cast(kind: SyntaxKind) -> bool { match kind { - NEVER_TYPE => true, + PIPE => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for PathType { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for Pipe { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - PATH_TYPE => true, + PIPE => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) } -} -impl PathType { - pub fn path(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PointerType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for PointerType { +pub struct Plus(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 AstNode for PointerType { +impl AstToken for Plus { fn can_cast(kind: SyntaxKind) -> bool { match kind { - POINTER_TYPE => true, + PLUS => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl PointerType { - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Plus { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + PLUS => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ArrayType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ArrayType { +pub struct Star(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 AstNode for ArrayType { +impl AstToken for Star { fn can_cast(kind: SyntaxKind) -> bool { match kind { - ARRAY_TYPE => true, + STAR => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl ArrayType { - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Star { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + STAR => true, + _ => false, + } } - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SliceType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for SliceType { +pub struct Slash(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 AstNode for SliceType { +impl AstToken for Slash { fn can_cast(kind: SyntaxKind) -> bool { match kind { - SLICE_TYPE => true, + SLASH => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl SliceType { - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Slash { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + SLASH => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ReferenceType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ReferenceType { +pub struct Caret(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 AstNode for ReferenceType { +impl AstToken for Caret { fn can_cast(kind: SyntaxKind) -> bool { match kind { - REFERENCE_TYPE => true, + CARET => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl ReferenceType { - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Caret { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + CARET => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PlaceholderType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for PlaceholderType { +pub struct Percent(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 AstNode for PlaceholderType { +impl AstToken for Percent { fn can_cast(kind: SyntaxKind) -> bool { match kind { - PLACEHOLDER_TYPE => true, + PERCENT => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for FnPointerType { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for Percent { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - FN_POINTER_TYPE => true, + PERCENT => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl FnPointerType { - pub fn param_list(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) } - pub fn ret_type(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ForType { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ForType { +pub struct Underscore(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 AstNode for ForType { +impl AstToken for Underscore { fn can_cast(kind: SyntaxKind) -> bool { match kind { - FOR_TYPE => true, + UNDERSCORE => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ForType { - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -#[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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for ImplTraitType { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for Underscore { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - IMPL_TRAIT_TYPE => true, + UNDERSCORE => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } -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 { +pub struct Dot(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 AstNode for DynTraitType { +impl AstToken for Dot { fn can_cast(kind: SyntaxKind) -> bool { match kind { - DYN_TRAIT_TYPE => true, + DOT => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for TupleExpr { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for Dot { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - TUPLE_EXPR => true, + DOT => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) } -} -impl TupleExpr { - pub fn exprs(&self) -> AstChildren { - AstChildren::new(&self.syntax) + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ArrayExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ArrayExpr { +pub struct Dotdot(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 AstNode for ArrayExpr { +impl AstToken for Dotdot { fn can_cast(kind: SyntaxKind) -> bool { match kind { - ARRAY_EXPR => true, + DOTDOT => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl ArrayExpr { - pub fn exprs(&self) -> AstChildren { - AstChildren::new(&self.syntax) + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -#[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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for ParenExpr { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for Dotdot { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - PAREN_EXPR => true, + DOTDOT => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) } -} -impl ParenExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PathExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for PathExpr { +pub struct Dotdotdot(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 AstNode for PathExpr { +impl AstToken for Dotdotdot { fn can_cast(kind: SyntaxKind) -> bool { match kind { - PATH_EXPR => true, + DOTDOTDOT => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl PathExpr { - pub fn path(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Dotdotdot { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + DOTDOTDOT => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LambdaExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for LambdaExpr { +pub struct Dotdoteq(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 AstNode for LambdaExpr { +impl AstToken for Dotdoteq { fn can_cast(kind: SyntaxKind) -> bool { match kind { - LAMBDA_EXPR => true, + DOTDOTEQ => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl LambdaExpr { - pub fn param_list(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Dotdoteq { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + DOTDOTEQ => true, + _ => false, + } } - pub fn ret_type(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } } - pub fn body(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct IfExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for IfExpr { +pub struct Colon(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 AstNode for IfExpr { +impl AstToken for Colon { fn can_cast(kind: SyntaxKind) -> bool { match kind { - IF_EXPR => true, + COLON => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl IfExpr { - pub fn condition(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Colon { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + COLON => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LoopExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for LoopExpr { +pub struct Coloncolon(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 AstNode for LoopExpr { +impl AstToken for Coloncolon { fn can_cast(kind: SyntaxKind) -> bool { match kind { - LOOP_EXPR => true, + COLONCOLON => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for TryBlockExpr { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for Coloncolon { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - TRY_BLOCK_EXPR => true, + COLONCOLON => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) } -} -impl TryBlockExpr { - pub fn body(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ForExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ForExpr { +pub struct Eq(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 AstNode for ForExpr { +impl AstToken for Eq { fn can_cast(kind: SyntaxKind) -> bool { match kind { - FOR_EXPR => true, + EQ => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl ast::LoopBodyOwner for ForExpr {} -impl ForExpr { - pub fn pat(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Eq { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + EQ => true, + _ => false, + } } - pub fn iterable(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WhileExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for WhileExpr { +pub struct Eqeq(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 AstNode for WhileExpr { +impl AstToken for Eqeq { fn can_cast(kind: SyntaxKind) -> bool { match kind { - WHILE_EXPR => true, + EQEQ => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl ast::LoopBodyOwner for WhileExpr {} -impl WhileExpr { - pub fn condition(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Eqeq { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + EQEQ => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ContinueExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ContinueExpr { +pub struct FatArrow(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 AstNode for ContinueExpr { +impl AstToken for FatArrow { fn can_cast(kind: SyntaxKind) -> bool { match kind { - CONTINUE_EXPR => true, + FAT_ARROW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for BreakExpr { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for FatArrow { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - BREAK_EXPR => true, + FAT_ARROW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) } -} -impl BreakExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Label { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for Label { +pub struct Excl(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 AstNode for Label { +impl AstToken for Excl { fn can_cast(kind: SyntaxKind) -> bool { match kind { - LABEL => true, + EXCL => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for BlockExpr { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for Excl { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - BLOCK_EXPR => true, + EXCL => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) } -} -impl BlockExpr { - pub fn block(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ReturnExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ReturnExpr { +pub struct Neq(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 AstNode for ReturnExpr { +impl AstToken for Neq { fn can_cast(kind: SyntaxKind) -> bool { match kind { - RETURN_EXPR => true, + NEQ => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl ReturnExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Neq { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + NEQ => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct CallExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for CallExpr { +pub struct Minus(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 AstNode for CallExpr { +impl AstToken for Minus { fn can_cast(kind: SyntaxKind) -> bool { match kind { - CALL_EXPR => true, + MINUS => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl ast::ArgListOwner for CallExpr {} -impl CallExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Minus { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + MINUS => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MethodCallExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for MethodCallExpr { +pub struct ThinArrow(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 AstNode for MethodCallExpr { +impl AstToken for ThinArrow { fn can_cast(kind: SyntaxKind) -> bool { match kind { - METHOD_CALL_EXPR => true, + THIN_ARROW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl ast::ArgListOwner for MethodCallExpr {} -impl MethodCallExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for ThinArrow { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + THIN_ARROW => true, + _ => false, + } } - pub fn name_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } } - pub fn type_arg_list(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct IndexExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for IndexExpr { +pub struct Lteq(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 AstNode for IndexExpr { +impl AstToken for Lteq { fn can_cast(kind: SyntaxKind) -> bool { match kind { - INDEX_EXPR => true, + LTEQ => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for FieldExpr { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for Lteq { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - FIELD_EXPR => true, + LTEQ => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl FieldExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) } - pub fn name_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct AwaitExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for AwaitExpr { +pub struct Gteq(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 AstNode for AwaitExpr { +impl AstToken for Gteq { fn can_cast(kind: SyntaxKind) -> bool { match kind { - AWAIT_EXPR => true, + GTEQ => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AwaitExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Gteq { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + GTEQ => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TryExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TryExpr { +pub struct Pluseq(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 AstNode for TryExpr { +impl AstToken for Pluseq { fn can_cast(kind: SyntaxKind) -> bool { match kind { - TRY_EXPR => true, + PLUSEQ => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl TryExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Pluseq { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + PLUSEQ => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct CastExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for CastExpr { +pub struct Minuseq(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 AstNode for CastExpr { +impl AstToken for Minuseq { fn can_cast(kind: SyntaxKind) -> bool { match kind { - CAST_EXPR => true, + MINUSEQ => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl CastExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Minuseq { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + MINUSEQ => true, + _ => false, + } } - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RefExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RefExpr { +pub struct Pipeeq(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 AstNode for RefExpr { +impl AstToken for Pipeeq { fn can_cast(kind: SyntaxKind) -> bool { match kind { - REF_EXPR => true, + PIPEEQ => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl RefExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Pipeeq { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + PIPEEQ => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PrefixExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for PrefixExpr { +pub struct Ampeq(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 AstNode for PrefixExpr { +impl AstToken for Ampeq { fn can_cast(kind: SyntaxKind) -> bool { match kind { - PREFIX_EXPR => true, + AMPEQ => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl PrefixExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Ampeq { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + AMPEQ => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct BoxExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for BoxExpr { +pub struct Careteq(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 AstNode for BoxExpr { +impl AstToken for Careteq { fn can_cast(kind: SyntaxKind) -> bool { match kind { - BOX_EXPR => true, + CARETEQ => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl BoxExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -#[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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for RangeExpr { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for Careteq { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - RANGE_EXPR => true, + CARETEQ => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } -impl RangeExpr {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct BinExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for BinExpr { +pub struct Slasheq(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 AstNode for BinExpr { +impl AstToken for Slasheq { fn can_cast(kind: SyntaxKind) -> bool { match kind { - BIN_EXPR => true, + SLASHEQ => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for Literal { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for Slasheq { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - LITERAL => true, + SLASHEQ => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } -impl Literal {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MatchExpr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for MatchExpr { +pub struct Stareq(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 AstNode for MatchExpr { +impl AstToken for Stareq { fn can_cast(kind: SyntaxKind) -> bool { match kind { - MATCH_EXPR => true, + STAREQ => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl MatchExpr { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Stareq { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + STAREQ => true, + _ => false, + } } - pub fn match_arm_list(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MatchArmList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for MatchArmList { +pub struct Percenteq(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 AstNode for MatchArmList { +impl AstToken for Percenteq { fn can_cast(kind: SyntaxKind) -> bool { match kind { - MATCH_ARM_LIST => true, + PERCENTEQ => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl ast::AttrsOwner for MatchArmList {} -impl MatchArmList { - pub fn arms(&self) -> AstChildren { - AstChildren::new(&self.syntax) +impl AstElement for Percenteq { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + PERCENTEQ => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MatchArm { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for MatchArm { +pub struct Ampamp(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 AstNode for MatchArm { +impl AstToken for Ampamp { fn can_cast(kind: SyntaxKind) -> bool { match kind { - MATCH_ARM => true, + AMPAMP => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl ast::AttrsOwner for MatchArm {} -impl MatchArm { - pub fn pat(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Ampamp { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + AMPAMP => true, + _ => false, + } } - pub fn guard(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } } - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MatchGuard { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for MatchGuard { +pub struct Pipepipe(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 AstNode for MatchGuard { +impl AstToken for Pipepipe { fn can_cast(kind: SyntaxKind) -> bool { match kind { - MATCH_GUARD => true, + PIPEPIPE => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl MatchGuard { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Pipepipe { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + PIPEPIPE => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordLit { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RecordLit { +pub struct Shl(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 AstNode for RecordLit { +impl AstToken for Shl { fn can_cast(kind: SyntaxKind) -> bool { match kind { - RECORD_LIT => true, + SHL => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl RecordLit { - pub fn path(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Shl { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + SHL => true, + _ => false, + } } - pub fn record_field_list(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordFieldList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RecordFieldList { +pub struct Shr(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 AstNode for RecordFieldList { +impl AstToken for Shr { fn can_cast(kind: SyntaxKind) -> bool { match kind { - RECORD_FIELD_LIST => true, + SHR => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl RecordFieldList { - pub fn fields(&self) -> AstChildren { - AstChildren::new(&self.syntax) +impl AstElement for Shr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + SHR => true, + _ => false, + } } - pub fn spread(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordField { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RecordField { +pub struct Shleq(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 AstNode for RecordField { +impl AstToken for Shleq { fn can_cast(kind: SyntaxKind) -> bool { match kind { - RECORD_FIELD => true, + SHLEQ => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl RecordField { - pub fn name_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for Shleq { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + SHLEQ => true, + _ => false, + } } - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct OrPat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for OrPat { +pub struct Shreq(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 AstNode for OrPat { +impl AstToken for Shreq { fn can_cast(kind: SyntaxKind) -> bool { match kind { - OR_PAT => true, + SHREQ => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl OrPat { - pub fn pats(&self) -> AstChildren { - AstChildren::new(&self.syntax) + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -#[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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for ParenPat { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for Shreq { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - PAREN_PAT => true, + SHREQ => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) } -} -impl ParenPat { - pub fn pat(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RefPat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RefPat { +pub struct AsKw(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 AstNode for RefPat { +impl AstToken for AsKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - REF_PAT => true, + AS_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl RefPat { - pub fn pat(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -#[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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for BoxPat { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for AsKw { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - BOX_PAT => true, + AS_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) } -} -impl BoxPat { - pub fn pat(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct BindPat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for BindPat { +pub struct AsyncKw(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 AstNode for BindPat { +impl AstToken for AsyncKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - BIND_PAT => true, + ASYNC_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl ast::NameOwner for BindPat {} -impl BindPat { - pub fn pat(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for AsyncKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + ASYNC_KW => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PlaceholderPat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for PlaceholderPat { +pub struct AwaitKw(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 AstNode for PlaceholderPat { +impl AstToken for AwaitKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - PLACEHOLDER_PAT => true, + AWAIT_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for DotDotPat { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for AwaitKw { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - DOT_DOT_PAT => true, + AWAIT_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } -impl DotDotPat {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PathPat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for PathPat { +pub struct BoxKw(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 AstNode for PathPat { +impl AstToken for BoxKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - PATH_PAT => true, + BOX_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl PathPat { - pub fn path(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for BoxKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + BOX_KW => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SlicePat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for SlicePat { +pub struct BreakKw(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 AstNode for SlicePat { +impl AstToken for BreakKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - SLICE_PAT => true, + BREAK_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -impl SlicePat { - pub fn args(&self) -> AstChildren { - AstChildren::new(&self.syntax) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -#[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 { +impl AstElement for BreakKw { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - RANGE_PAT => true, + BREAK_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } -impl RangePat {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LiteralPat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for LiteralPat { +pub struct ConstKw(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 AstNode for LiteralPat { +impl AstToken for ConstKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - LITERAL_PAT => true, + CONST_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl LiteralPat { - pub fn literal(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for ConstKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + CONST_KW => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordPat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RecordPat { +pub struct ContinueKw(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 AstNode for RecordPat { +impl AstToken for ContinueKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - RECORD_PAT => true, + CONTINUE_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl RecordPat { - pub fn record_field_pat_list(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for ContinueKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + CONTINUE_KW => true, + _ => false, + } } - pub fn path(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordFieldPatList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RecordFieldPatList { +pub struct CrateKw(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 AstNode for RecordFieldPatList { +impl AstToken for CrateKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - RECORD_FIELD_PAT_LIST => true, + CRATE_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl RecordFieldPatList { - pub fn record_field_pats(&self) -> AstChildren { - AstChildren::new(&self.syntax) +impl AstElement for CrateKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + CRATE_KW => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } } - pub fn bind_pats(&self) -> AstChildren { - AstChildren::new(&self.syntax) + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct RecordFieldPat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for RecordFieldPat { +pub struct DynKw(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 AstNode for RecordFieldPat { +impl AstToken for DynKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - RECORD_FIELD_PAT => true, + DYN_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl ast::NameOwner for RecordFieldPat {} -impl RecordFieldPat { - pub fn pat(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for DynKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + DYN_KW => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TupleStructPat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TupleStructPat { +pub struct ElseKw(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 AstNode for TupleStructPat { +impl AstToken for ElseKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - TUPLE_STRUCT_PAT => true, + ELSE_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl TupleStructPat { - pub fn path(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for ElseKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + ELSE_KW => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } } - pub fn args(&self) -> AstChildren { - AstChildren::new(&self.syntax) + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TuplePat { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TuplePat { +pub struct EnumKw(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 AstNode for TuplePat { +impl AstToken for EnumKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - TUPLE_PAT => true, + ENUM_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl TuplePat { - pub fn args(&self) -> AstChildren { - AstChildren::new(&self.syntax) + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -#[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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for Visibility { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for EnumKw { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - VISIBILITY => true, + ENUM_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } -impl Visibility {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Name { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for Name { +pub struct ExternKw(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 AstNode for Name { +impl AstToken for ExternKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - NAME => true, + EXTERN_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for NameRef { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for ExternKw { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - NAME_REF => true, + EXTERN_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } -impl NameRef {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MacroCall { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for MacroCall { +pub struct FalseKw(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 AstNode for MacroCall { +impl AstToken for FalseKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - MACRO_CALL => true, + FALSE_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -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() +impl AstElement for FalseKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + FALSE_KW => true, + _ => false, + } } - pub fn path(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Attr { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for Attr { +pub struct FnKw(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 AstNode for Attr { +impl AstToken for FnKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - ATTR => true, + FN_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl Attr { - pub fn path(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for FnKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + FN_KW => true, + _ => false, + } } - pub fn input(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TokenTree { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TokenTree { +pub struct ForKw(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 AstNode for TokenTree { +impl AstToken for ForKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - TOKEN_TREE => true, + FOR_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for TypeParamList { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for ForKw { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - TYPE_PARAM_LIST => true, + FOR_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl TypeParamList { - pub fn type_params(&self) -> AstChildren { - AstChildren::new(&self.syntax) + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) } - pub fn lifetime_params(&self) -> AstChildren { - AstChildren::new(&self.syntax) + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TypeParam { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TypeParam { +pub struct IfKw(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 AstNode for TypeParam { +impl AstToken for IfKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - TYPE_PARAM => true, + IF_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -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() +impl AstElement for IfKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + IF_KW => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ConstParam { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ConstParam { +pub struct ImplKw(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 AstNode for ConstParam { +impl AstToken for ImplKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - CONST_PARAM => true, + IMPL_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -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() +impl AstElement for ImplKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + IMPL_KW => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LifetimeParam { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for LifetimeParam { +pub struct InKw(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 AstNode for LifetimeParam { +impl AstToken for InKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - LIFETIME_PARAM => true, + IN_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for TypeBound { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for InKw { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - TYPE_BOUND => true, + IN_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) } -} -impl TypeBound { - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TypeBoundList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TypeBoundList { +pub struct LetKw(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 AstNode for TypeBoundList { +impl AstToken for LetKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - TYPE_BOUND_LIST => true, + LET_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl TypeBoundList { - pub fn bounds(&self) -> AstChildren { - AstChildren::new(&self.syntax) + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -#[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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for WherePred { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for LetKw { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - WHERE_PRED => true, + LET_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) } -} -impl ast::TypeBoundsOwner for WherePred {} -impl WherePred { - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct WhereClause { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for WhereClause { +pub struct LoopKw(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 AstNode for WhereClause { +impl AstToken for LoopKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - WHERE_CLAUSE => true, + LOOP_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl WhereClause { - pub fn predicates(&self) -> AstChildren { - AstChildren::new(&self.syntax) + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -#[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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for ExprStmt { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for LoopKw { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - EXPR_STMT => true, + LOOP_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) } -} -impl ExprStmt { - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LetStmt { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for LetStmt { +pub struct MacroKw(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 AstNode for LetStmt { +impl AstToken for MacroKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - LET_STMT => true, + MACRO_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl ast::TypeAscriptionOwner for LetStmt {} -impl LetStmt { - pub fn pat(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for MacroKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + MACRO_KW => true, + _ => false, + } } - pub fn initializer(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Condition { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for Condition { +pub struct MatchKw(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 AstNode for Condition { +impl AstToken for MatchKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - CONDITION => true, + MATCH_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl Condition { - pub fn pat(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for MatchKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + MATCH_KW => true, + _ => false, + } } - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Block { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for Block { +pub struct ModKw(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 AstNode for Block { +impl AstToken for ModKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - BLOCK => true, + MOD_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl ast::AttrsOwner for Block {} -impl ast::ModuleItemOwner for Block {} -impl Block { - pub fn statements(&self) -> AstChildren { - AstChildren::new(&self.syntax) +impl AstElement for ModKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + MOD_KW => true, + _ => false, + } } - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ParamList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ParamList { +pub struct MoveKw(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 AstNode for ParamList { +impl AstToken for MoveKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - PARAM_LIST => true, + MOVE_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl ParamList { - pub fn self_param(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for MoveKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + MOVE_KW => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } } - pub fn params(&self) -> AstChildren { - AstChildren::new(&self.syntax) + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct SelfParam { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for SelfParam { +pub struct MutKw(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 AstNode for SelfParam { +impl AstToken for MutKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - SELF_PARAM => true, + MUT_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -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) + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AstNode for Param { - fn can_cast(kind: SyntaxKind) -> bool { +impl AstElement for MutKw { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - PARAM => true, + MUT_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) } -} -impl ast::TypeAscriptionOwner for Param {} -impl ast::AttrsOwner for Param {} -impl Param { - pub fn pat(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct UseItem { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for UseItem { +pub struct PubKw(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 AstNode for UseItem { +impl AstToken for PubKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - USE_ITEM => true, + PUB_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl ast::AttrsOwner for UseItem {} -impl ast::VisibilityOwner for UseItem {} -impl UseItem { - pub fn use_tree(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for PubKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + PUB_KW => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct UseTree { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for UseTree { +pub struct RefKw(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 AstNode for UseTree { +impl AstToken for RefKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - USE_TREE => true, + REF_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl UseTree { - pub fn path(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for RefKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + REF_KW => true, + _ => false, + } } - pub fn use_tree_list(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } } - pub fn alias(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Alias { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for Alias { +pub struct ReturnKw(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 AstNode for Alias { +impl AstToken for ReturnKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - ALIAS => true, + RETURN_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -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 { +impl AstElement for ReturnKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + RETURN_KW => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SelfKw(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 AstNode for UseTreeList { +impl AstToken for SelfKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - USE_TREE_LIST => true, + SELF_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl UseTreeList { - pub fn use_trees(&self) -> AstChildren { - AstChildren::new(&self.syntax) +impl AstElement for SelfKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + SELF_KW => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ExternCrateItem { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ExternCrateItem { +pub struct StaticKw(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 AstNode for ExternCrateItem { +impl AstToken for StaticKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - EXTERN_CRATE_ITEM => true, + STATIC_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl ast::AttrsOwner for ExternCrateItem {} -impl ast::VisibilityOwner for ExternCrateItem {} -impl ExternCrateItem { - pub fn name_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for StaticKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + STATIC_KW => true, + _ => false, + } } - pub fn alias(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ArgList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for ArgList { +pub struct StructKw(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 AstNode for ArgList { +impl AstToken for StructKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - ARG_LIST => true, + STRUCT_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl ArgList { - pub fn args(&self) -> AstChildren { - AstChildren::new(&self.syntax) +impl AstElement for StructKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + STRUCT_KW => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Path { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for Path { +pub struct SuperKw(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 AstNode for Path { +impl AstToken for SuperKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - PATH => true, + SUPER_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl Path { - pub fn segment(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for SuperKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + SUPER_KW => true, + _ => false, + } } - pub fn qualifier(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct PathSegment { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for PathSegment { +pub struct TraitKw(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 AstNode for PathSegment { +impl AstToken for TraitKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - PATH_SEGMENT => true, + TRAIT_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 } -} -impl PathSegment { - pub fn name_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn into_syntax(self) -> SyntaxToken { + self.0 } - pub fn type_arg_list(&self) -> Option { - AstChildren::new(&self.syntax).next() +} +impl AstElement for TraitKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TRAIT_KW => true, + _ => false, + } } - pub fn param_list(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } } - pub fn ret_type(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) } - pub fn path_type(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TypeArgList { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TypeArgList { +pub struct TrueKw(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 AstNode for TypeArgList { +impl AstToken for TrueKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - TYPE_ARG_LIST => true, + TRUE_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl TypeArgList { - pub fn type_args(&self) -> AstChildren { - AstChildren::new(&self.syntax) +impl AstElement for TrueKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TRUE_KW => true, + _ => false, + } } - pub fn lifetime_args(&self) -> AstChildren { - AstChildren::new(&self.syntax) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } } - pub fn assoc_type_args(&self) -> AstChildren { - AstChildren::new(&self.syntax) + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) } - pub fn const_arg(&self) -> AstChildren { - AstChildren::new(&self.syntax) + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct TypeArg { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for TypeArg { +pub struct TryKw(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 AstNode for TypeArg { +impl AstToken for TryKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - TYPE_ARG => true, + TRY_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl TypeArg { - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for TryKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TRY_KW => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct AssocTypeArg { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for AssocTypeArg { +pub struct TypeKw(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 AstNode for AssocTypeArg { +impl AstToken for TypeKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - ASSOC_TYPE_ARG => true, + TYPE_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl AssocTypeArg { - pub fn name_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for TypeKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TYPE_KW => true, + _ => false, + } } - pub fn type_ref(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct LifetimeArg { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for LifetimeArg { +pub struct UnsafeKw(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 AstNode for LifetimeArg { +impl AstToken for UnsafeKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - LIFETIME_ARG => true, + UNSAFE_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl LifetimeArg {} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct ConstArg { - pub(crate) syntax: SyntaxNode, +impl AstElement for UnsafeKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + UNSAFE_KW => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } } -impl std::fmt::Display for ConstArg { +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct UseKw(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 AstNode for ConstArg { +impl AstToken for UseKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - CONST_ARG => true, + USE_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -impl ConstArg { - pub fn literal(&self) -> Option { - AstChildren::new(&self.syntax).next() +impl AstElement for UseKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + USE_KW => true, + _ => false, + } } - pub fn block_expr(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct MacroItems { - pub(crate) syntax: SyntaxNode, -} -impl std::fmt::Display for MacroItems { +pub struct WhereKw(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 AstNode for MacroItems { +impl AstToken for WhereKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - MACRO_ITEMS => true, + WHERE_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 } } -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 AstElement for WhereKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + WHERE_KW => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } } -impl std::fmt::Display for MacroStmts { +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct WhileKw(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 AstNode for MacroStmts { +impl AstToken for WhileKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - MACRO_STMTS => true, + WHILE_KW => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxToken) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self(syntax)) } else { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax - } -} -impl MacroStmts { - pub fn statements(&self) -> AstChildren { - AstChildren::new(&self.syntax) + fn syntax(&self) -> &SyntaxToken { + &self.0 } - pub fn expr(&self) -> Option { - AstChildren::new(&self.syntax).next() + fn into_syntax(self) -> SyntaxToken { + self.0 } } -#[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 AstElement for WhileKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + WHILE_KW => true, + _ => false, + } } -} -impl From for NominalDef { - fn from(node: EnumDef) -> NominalDef { - NominalDef::EnumDef(node) + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } } -} -impl From for NominalDef { - fn from(node: UnionDef) -> NominalDef { - NominalDef::UnionDef(node) + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) } } -impl std::fmt::Display for NominalDef { +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AutoKw(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 AstNode for NominalDef { +impl AstToken for AutoKw { fn can_cast(kind: SyntaxKind) -> bool { match kind { - STRUCT_DEF | ENUM_DEF | UNION_DEF => true, + AUTO_KW => 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 cast_or_return(syntax: SyntaxToken) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self(syntax)) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 + } +} +impl AstElement for AutoKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + AUTO_KW => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DefaultKw(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_or_return(syntax: SyntaxToken) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self(syntax)) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 + } +} +impl AstElement for DefaultKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + DEFAULT_KW => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ExistentialKw(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_or_return(syntax: SyntaxToken) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self(syntax)) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 + } +} +impl AstElement for ExistentialKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + EXISTENTIAL_KW => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct UnionKw(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_or_return(syntax: SyntaxToken) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self(syntax)) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 + } +} +impl AstElement for UnionKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + UNION_KW => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RawKw(SyntaxToken); +impl std::fmt::Display for RawKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} +impl AstToken for RawKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + RAW_KW => true, + _ => false, + } + } + fn cast_or_return(syntax: SyntaxToken) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self(syntax)) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 + } +} +impl AstElement for RawKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + RAW_KW => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct IntNumber(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_or_return(syntax: SyntaxToken) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self(syntax)) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 + } +} +impl AstElement for IntNumber { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + INT_NUMBER => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct FloatNumber(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_or_return(syntax: SyntaxToken) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self(syntax)) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 + } +} +impl AstElement for FloatNumber { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + FLOAT_NUMBER => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Char(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_or_return(syntax: SyntaxToken) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self(syntax)) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 + } +} +impl AstElement for Char { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + CHAR => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Byte(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_or_return(syntax: SyntaxToken) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self(syntax)) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 + } +} +impl AstElement for Byte { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + BYTE => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct String(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_or_return(syntax: SyntaxToken) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self(syntax)) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 + } +} +impl AstElement for String { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + STRING => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RawString(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_or_return(syntax: SyntaxToken) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self(syntax)) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 + } +} +impl AstElement for RawString { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + RAW_STRING => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ByteString(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_or_return(syntax: SyntaxToken) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self(syntax)) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 + } +} +impl AstElement for ByteString { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + BYTE_STRING => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RawByteString(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_or_return(syntax: SyntaxToken) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self(syntax)) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 + } +} +impl AstElement for RawByteString { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + RAW_BYTE_STRING => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Error(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_or_return(syntax: SyntaxToken) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self(syntax)) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 + } +} +impl AstElement for Error { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + ERROR => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Ident(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_or_return(syntax: SyntaxToken) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self(syntax)) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 + } +} +impl AstElement for Ident { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + IDENT => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Whitespace(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_or_return(syntax: SyntaxToken) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self(syntax)) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 + } +} +impl AstElement for Whitespace { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + WHITESPACE => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Lifetime(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_or_return(syntax: SyntaxToken) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self(syntax)) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 + } +} +impl AstElement for Lifetime { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + LIFETIME => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Comment(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_or_return(syntax: SyntaxToken) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self(syntax)) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 + } +} +impl AstElement for Comment { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + COMMENT => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Shebang(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_or_return(syntax: SyntaxToken) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self(syntax)) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 + } +} +impl AstElement for Shebang { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + SHEBANG => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct LDollar(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_or_return(syntax: SyntaxToken) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self(syntax)) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 + } +} +impl AstElement for LDollar { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + L_DOLLAR => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RDollar(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_or_return(syntax: SyntaxToken) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self(syntax)) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxToken { + &self.0 + } + fn into_syntax(self) -> SyntaxToken { + self.0 + } +} +impl AstElement for RDollar { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + R_DOLLAR => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self(syntax.into_token().unwrap())) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Token(&self.0) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Token(self.0) + } +} +#[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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for SourceFile { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + SOURCE_FILE => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ast::ModuleItemOwner for SourceFile {} +impl ast::FnDefOwner for SourceFile {} +impl ast::AttrsOwner for SourceFile {} +impl SourceFile { + pub fn modules(&self) -> impl Iterator + Clone { + self.syntax.children().filter_map(Module::cast) + } +} +#[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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for FnDef { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + FN_DEF => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(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 abi(&self) -> Option { + self.syntax.children().filter_map(Abi::cast).next() + } + pub fn const_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(ConstKw::cast_element).next() + } + pub fn default_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(DefaultKw::cast_element).next() + } + pub fn async_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(AsyncKw::cast_element).next() + } + pub fn unsafe_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(UnsafeKw::cast_element).next() + } + pub fn fn_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(FnKw::cast_element).next() + } + pub fn param_list(&self) -> Option { + self.syntax.children().filter_map(ParamList::cast).next() + } + pub fn ret_type(&self) -> Option { + self.syntax.children().filter_map(RetType::cast).next() + } + pub fn body(&self) -> Option { + self.syntax.children().filter_map(BlockExpr::cast).next() + } + pub fn semi(&self) -> Option { + self.syntax.children_with_tokens().filter_map(Semi::cast_element).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for RetType { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + RET_TYPE => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl RetType { + pub fn thin_arrow(&self) -> Option { + self.syntax.children_with_tokens().filter_map(ThinArrow::cast_element).next() + } + pub fn type_ref(&self) -> Option { + self.syntax.children().filter_map(TypeRef::cast).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for StructDef { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + STRUCT_DEF => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(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 { + pub fn struct_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(StructKw::cast_element).next() + } + pub fn field_def_list(&self) -> Option { + self.syntax.children().filter_map(FieldDefList::cast).next() + } + pub fn semi(&self) -> Option { + self.syntax.children_with_tokens().filter_map(Semi::cast_element).next() + } +} +#[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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for UnionDef { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + UNION_DEF => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(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 union_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(UnionKw::cast_element).next() + } + pub fn record_field_def_list(&self) -> Option { + self.syntax.children().filter_map(RecordFieldDefList::cast).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for RecordFieldDefList { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + RECORD_FIELD_DEF_LIST => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl RecordFieldDefList { + pub fn l_curly(&self) -> Option { + self.syntax.children_with_tokens().filter_map(LCurly::cast_element).next() + } + pub fn fields(&self) -> impl Iterator + Clone { + self.syntax.children().filter_map(RecordFieldDef::cast) + } + pub fn r_curly(&self) -> Option { + self.syntax.children_with_tokens().filter_map(RCurly::cast_element).next() + } +} +#[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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for RecordFieldDef { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + RECORD_FIELD_DEF => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for TupleFieldDefList { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TUPLE_FIELD_DEF_LIST => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl TupleFieldDefList { + pub fn l_paren(&self) -> Option { + self.syntax.children_with_tokens().filter_map(LParen::cast_element).next() + } + pub fn fields(&self) -> impl Iterator + Clone { + self.syntax.children().filter_map(TupleFieldDef::cast) + } + pub fn r_paren(&self) -> Option { + self.syntax.children_with_tokens().filter_map(RParen::cast_element).next() + } +} +#[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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for TupleFieldDef { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TUPLE_FIELD_DEF => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ast::VisibilityOwner for TupleFieldDef {} +impl ast::AttrsOwner for TupleFieldDef {} +impl TupleFieldDef { + pub fn type_ref(&self) -> Option { + self.syntax.children().filter_map(TypeRef::cast).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for EnumDef { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + ENUM_DEF => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(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 enum_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(EnumKw::cast_element).next() + } + pub fn variant_list(&self) -> Option { + self.syntax.children().filter_map(EnumVariantList::cast).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for EnumVariantList { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + ENUM_VARIANT_LIST => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl EnumVariantList { + pub fn l_curly(&self) -> Option { + self.syntax.children_with_tokens().filter_map(LCurly::cast_element).next() + } + pub fn variants(&self) -> impl Iterator + Clone { + self.syntax.children().filter_map(EnumVariant::cast) + } + pub fn r_curly(&self) -> Option { + self.syntax.children_with_tokens().filter_map(RCurly::cast_element).next() + } +} +#[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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for EnumVariant { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + ENUM_VARIANT => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ast::VisibilityOwner for EnumVariant {} +impl ast::NameOwner for EnumVariant {} +impl ast::DocCommentsOwner for EnumVariant {} +impl ast::AttrsOwner for EnumVariant {} +impl EnumVariant { + pub fn field_def_list(&self) -> Option { + self.syntax + .children_with_tokens() + .take_while(|x| !Eq::can_cast_element(x.kind())) + .filter_map(FieldDefList::cast_element) + .next() + } + pub fn eq(&self) -> Option { + self.syntax.children_with_tokens().filter_map(Eq::cast_element).next() + } + pub fn expr(&self) -> Option { + self.syntax + .children_with_tokens() + .skip_while(|x| !Eq::can_cast_element(x.kind())) + .skip(1) + .filter_map(Expr::cast_element) + .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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for TraitDef { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TRAIT_DEF => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(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 unsafe_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(UnsafeKw::cast_element).next() + } + pub fn auto_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(AutoKw::cast_element).next() + } + pub fn trait_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(TraitKw::cast_element).next() + } + pub fn item_list(&self) -> Option { + self.syntax.children().filter_map(ItemList::cast).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for Module { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + MODULE => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(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 mod_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(ModKw::cast_element).next() + } + pub fn item_list(&self) -> Option { + self.syntax.children().filter_map(ItemList::cast).next() + } + pub fn semi(&self) -> Option { + self.syntax.children_with_tokens().filter_map(Semi::cast_element).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for ItemList { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + ITEM_LIST => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ast::FnDefOwner for ItemList {} +impl ast::ModuleItemOwner for ItemList {} +impl ItemList { + pub fn l_curly(&self) -> Option { + self.syntax.children_with_tokens().filter_map(LCurly::cast_element).next() + } + pub fn impl_items(&self) -> impl Iterator + Clone { + self.syntax.children().filter_map(ImplItem::cast) + } + pub fn r_curly(&self) -> Option { + self.syntax.children_with_tokens().filter_map(RCurly::cast_element).next() + } +} +#[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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for ConstDef { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + CONST_DEF => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(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 default_kw(&self) -> Option { + self.syntax + .children_with_tokens() + .take_while(|x| !Eq::can_cast_element(x.kind())) + .filter_map(DefaultKw::cast_element) + .next() + } + pub fn const_kw(&self) -> Option { + self.syntax + .children_with_tokens() + .take_while(|x| !Eq::can_cast_element(x.kind())) + .filter_map(ConstKw::cast_element) + .next() + } + pub fn eq(&self) -> Option { + self.syntax.children_with_tokens().filter_map(Eq::cast_element).next() + } + pub fn body(&self) -> Option { + self.syntax + .children_with_tokens() + .skip_while(|x| !Eq::can_cast_element(x.kind())) + .skip(1) + .filter_map(Expr::cast_element) + .next() + } + pub fn semi(&self) -> Option { + self.syntax + .children_with_tokens() + .skip_while(|x| !Eq::can_cast_element(x.kind())) + .skip(1) + .filter_map(Semi::cast_element) + .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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for StaticDef { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + STATIC_DEF => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(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 static_kw(&self) -> Option { + self.syntax + .children_with_tokens() + .take_while(|x| !Eq::can_cast_element(x.kind())) + .filter_map(StaticKw::cast_element) + .next() + } + pub fn mut_kw(&self) -> Option { + self.syntax + .children_with_tokens() + .take_while(|x| !Eq::can_cast_element(x.kind())) + .filter_map(MutKw::cast_element) + .next() + } + pub fn eq(&self) -> Option { + self.syntax.children_with_tokens().filter_map(Eq::cast_element).next() + } + pub fn body(&self) -> Option { + self.syntax + .children_with_tokens() + .skip_while(|x| !Eq::can_cast_element(x.kind())) + .skip(1) + .filter_map(Expr::cast_element) + .next() + } + pub fn semi(&self) -> Option { + self.syntax + .children_with_tokens() + .skip_while(|x| !Eq::can_cast_element(x.kind())) + .skip(1) + .filter_map(Semi::cast_element) + .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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for TypeAliasDef { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TYPE_ALIAS_DEF => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(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 default_kw(&self) -> Option { + self.syntax + .children_with_tokens() + .take_while(|x| !Eq::can_cast_element(x.kind())) + .filter_map(DefaultKw::cast_element) + .next() + } + pub fn type_kw(&self) -> Option { + self.syntax + .children_with_tokens() + .take_while(|x| !Eq::can_cast_element(x.kind())) + .filter_map(TypeKw::cast_element) + .next() + } + pub fn eq(&self) -> Option { + self.syntax.children_with_tokens().filter_map(Eq::cast_element).next() + } + pub fn type_ref(&self) -> Option { + self.syntax + .children_with_tokens() + .skip_while(|x| !Eq::can_cast_element(x.kind())) + .skip(1) + .filter_map(TypeRef::cast_element) + .next() + } + pub fn semi(&self) -> Option { + self.syntax + .children_with_tokens() + .skip_while(|x| !Eq::can_cast_element(x.kind())) + .skip(1) + .filter_map(Semi::cast_element) + .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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for ImplDef { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + IMPL_DEF => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ast::TypeParamsOwner for ImplDef {} +impl ast::AttrsOwner for ImplDef {} +impl ImplDef { + pub fn default_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(DefaultKw::cast_element).next() + } + pub fn const_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(ConstKw::cast_element).next() + } + pub fn unsafe_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(UnsafeKw::cast_element).next() + } + pub fn impl_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(ImplKw::cast_element).next() + } + pub fn excl(&self) -> Option { + self.syntax.children_with_tokens().filter_map(Excl::cast_element).next() + } + pub fn for_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(ForKw::cast_element).next() + } + pub fn item_list(&self) -> Option { + self.syntax.children().filter_map(ItemList::cast).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for ParenType { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + PAREN_TYPE => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ParenType { + pub fn l_paren(&self) -> Option { + self.syntax.children_with_tokens().filter_map(LParen::cast_element).next() + } + pub fn type_ref(&self) -> Option { + self.syntax.children().filter_map(TypeRef::cast).next() + } + pub fn r_paren(&self) -> Option { + self.syntax.children_with_tokens().filter_map(RParen::cast_element).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for TupleType { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TUPLE_TYPE => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl TupleType { + pub fn l_paren(&self) -> Option { + self.syntax.children_with_tokens().filter_map(LParen::cast_element).next() + } + pub fn fields(&self) -> impl Iterator + Clone { + self.syntax.children().filter_map(TypeRef::cast) + } + pub fn r_paren(&self) -> Option { + self.syntax.children_with_tokens().filter_map(RParen::cast_element).next() + } +} +#[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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for NeverType { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + NEVER_TYPE => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl NeverType { + pub fn excl(&self) -> Option { + self.syntax.children_with_tokens().filter_map(Excl::cast_element).next() + } +} +#[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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for PathType { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + PATH_TYPE => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl PathType { + pub fn path(&self) -> Option { + self.syntax.children().filter_map(Path::cast).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for PointerType { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + POINTER_TYPE => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl PointerType { + pub fn star(&self) -> Option { + self.syntax.children_with_tokens().filter_map(Star::cast_element).next() + } + pub fn const_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(ConstKw::cast_element).next() + } + pub fn type_ref(&self) -> Option { + self.syntax.children().filter_map(TypeRef::cast).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for ArrayType { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + ARRAY_TYPE => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ArrayType { + pub fn l_brack(&self) -> Option { + self.syntax.children_with_tokens().filter_map(LBrack::cast_element).next() + } + pub fn type_ref(&self) -> Option { + self.syntax.children().filter_map(TypeRef::cast).next() + } + pub fn semi(&self) -> Option { + self.syntax.children_with_tokens().filter_map(Semi::cast_element).next() + } + pub fn expr(&self) -> Option { + self.syntax.children().filter_map(Expr::cast).next() + } + pub fn r_brack(&self) -> Option { + self.syntax.children_with_tokens().filter_map(RBrack::cast_element).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for SliceType { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + SLICE_TYPE => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl SliceType { + pub fn l_brack(&self) -> Option { + self.syntax.children_with_tokens().filter_map(LBrack::cast_element).next() + } + pub fn type_ref(&self) -> Option { + self.syntax.children().filter_map(TypeRef::cast).next() + } + pub fn r_brack(&self) -> Option { + self.syntax.children_with_tokens().filter_map(RBrack::cast_element).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for ReferenceType { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + REFERENCE_TYPE => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ReferenceType { + pub fn amp(&self) -> Option { + self.syntax.children_with_tokens().filter_map(Amp::cast_element).next() + } + pub fn lifetime(&self) -> Option { + self.syntax.children_with_tokens().filter_map(Lifetime::cast_element).next() + } + pub fn mut_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(MutKw::cast_element).next() + } + pub fn type_ref(&self) -> Option { + self.syntax.children().filter_map(TypeRef::cast).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for PlaceholderType { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + PLACEHOLDER_TYPE => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl PlaceholderType { + pub fn underscore(&self) -> Option { + self.syntax.children_with_tokens().filter_map(Underscore::cast_element).next() + } +} +#[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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for FnPointerType { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + FN_POINTER_TYPE => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl FnPointerType { + pub fn abi(&self) -> Option { + self.syntax.children().filter_map(Abi::cast).next() + } + pub fn unsafe_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(UnsafeKw::cast_element).next() + } + pub fn fn_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(FnKw::cast_element).next() + } + pub fn param_list(&self) -> Option { + self.syntax.children().filter_map(ParamList::cast).next() + } + pub fn ret_type(&self) -> Option { + self.syntax.children().filter_map(RetType::cast).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for ForType { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + FOR_TYPE => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ForType { + pub fn for_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(ForKw::cast_element).next() + } + pub fn type_param_list(&self) -> Option { + self.syntax.children().filter_map(TypeParamList::cast).next() + } + pub fn type_ref(&self) -> Option { + self.syntax.children().filter_map(TypeRef::cast).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for ImplTraitType { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + IMPL_TRAIT_TYPE => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ast::TypeBoundsOwner for ImplTraitType {} +impl ImplTraitType { + pub fn impl_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(ImplKw::cast_element).next() + } +} +#[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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for DynTraitType { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + DYN_TRAIT_TYPE => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ast::TypeBoundsOwner for DynTraitType {} +impl DynTraitType { + pub fn dyn_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(DynKw::cast_element).next() + } +} +#[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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for TupleExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TUPLE_EXPR => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ast::AttrsOwner for TupleExpr {} +impl TupleExpr { + pub fn l_paren(&self) -> Option { + self.syntax.children_with_tokens().filter_map(LParen::cast_element).next() + } + pub fn exprs(&self) -> impl Iterator + Clone { + self.syntax.children().filter_map(Expr::cast) + } + pub fn r_paren(&self) -> Option { + self.syntax.children_with_tokens().filter_map(RParen::cast_element).next() + } +} +#[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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for ArrayExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + ARRAY_EXPR => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ast::AttrsOwner for ArrayExpr {} +impl ArrayExpr { + pub fn l_brack(&self) -> Option { + self.syntax.children_with_tokens().filter_map(LBrack::cast_element).next() + } + pub fn exprs(&self) -> impl Iterator + Clone { + self.syntax.children().filter_map(Expr::cast) + } + pub fn semi(&self) -> Option { + self.syntax.children_with_tokens().filter_map(Semi::cast_element).next() + } + pub fn r_brack(&self) -> Option { + self.syntax.children_with_tokens().filter_map(RBrack::cast_element).next() + } +} +#[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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for ParenExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + PAREN_EXPR => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ast::AttrsOwner for ParenExpr {} +impl ParenExpr { + pub fn l_paren(&self) -> Option { + self.syntax.children_with_tokens().filter_map(LParen::cast_element).next() + } + pub fn expr(&self) -> Option { + self.syntax.children().filter_map(Expr::cast).next() + } + pub fn r_paren(&self) -> Option { + self.syntax.children_with_tokens().filter_map(RParen::cast_element).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for PathExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + PATH_EXPR => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl PathExpr { + pub fn path(&self) -> Option { + self.syntax.children().filter_map(Path::cast).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for LambdaExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + LAMBDA_EXPR => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ast::AttrsOwner for LambdaExpr {} +impl LambdaExpr { + pub fn static_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(StaticKw::cast_element).next() + } + pub fn async_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(AsyncKw::cast_element).next() + } + pub fn move_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(MoveKw::cast_element).next() + } + pub fn param_list(&self) -> Option { + self.syntax.children().filter_map(ParamList::cast).next() + } + pub fn ret_type(&self) -> Option { + self.syntax.children().filter_map(RetType::cast).next() + } + pub fn body(&self) -> Option { + self.syntax.children().filter_map(Expr::cast).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for IfExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + IF_EXPR => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ast::AttrsOwner for IfExpr {} +impl IfExpr { + pub fn if_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(IfKw::cast_element).next() + } + pub fn condition(&self) -> Option { + self.syntax.children().filter_map(Condition::cast).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for LoopExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + LOOP_EXPR => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ast::AttrsOwner for LoopExpr {} +impl ast::LoopBodyOwner for LoopExpr {} +impl LoopExpr { + pub fn loop_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(LoopKw::cast_element).next() + } +} +#[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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for TryBlockExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TRY_BLOCK_EXPR => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ast::AttrsOwner for TryBlockExpr {} +impl TryBlockExpr { + pub fn try_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(TryKw::cast_element).next() + } + pub fn body(&self) -> Option { + self.syntax.children().filter_map(BlockExpr::cast).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for ForExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + FOR_EXPR => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ast::AttrsOwner for ForExpr {} +impl ast::LoopBodyOwner for ForExpr {} +impl ForExpr { + pub fn for_kw(&self) -> Option { + self.syntax + .children_with_tokens() + .take_while(|x| !InKw::can_cast_element(x.kind())) + .filter_map(ForKw::cast_element) + .next() + } + pub fn pat(&self) -> Option { + self.syntax + .children_with_tokens() + .take_while(|x| !InKw::can_cast_element(x.kind())) + .filter_map(Pat::cast_element) + .next() + } + pub fn in_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(InKw::cast_element).next() + } + pub fn iterable(&self) -> Option { + self.syntax + .children_with_tokens() + .skip_while(|x| !InKw::can_cast_element(x.kind())) + .skip(1) + .filter_map(Expr::cast_element) + .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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for WhileExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + WHILE_EXPR => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ast::AttrsOwner for WhileExpr {} +impl ast::LoopBodyOwner for WhileExpr {} +impl WhileExpr { + pub fn while_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(WhileKw::cast_element).next() + } + pub fn condition(&self) -> Option { + self.syntax.children().filter_map(Condition::cast).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for ContinueExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + CONTINUE_EXPR => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ast::AttrsOwner for ContinueExpr {} +impl ContinueExpr { + pub fn continue_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(ContinueKw::cast_element).next() + } + pub fn lifetime(&self) -> Option { + self.syntax.children_with_tokens().filter_map(Lifetime::cast_element).next() + } +} +#[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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for BreakExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + BREAK_EXPR => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ast::AttrsOwner for BreakExpr {} +impl BreakExpr { + pub fn break_kw(&self) -> Option { + self.syntax.children_with_tokens().filter_map(BreakKw::cast_element).next() + } + pub fn lifetime(&self) -> Option { + self.syntax.children_with_tokens().filter_map(Lifetime::cast_element).next() + } + pub fn expr(&self) -> Option { + self.syntax.children().filter_map(Expr::cast).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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for Label { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + LABEL => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl Label { + pub fn lifetime(&self) -> Option { + self.syntax.children_with_tokens().filter_map(Lifetime::cast_element).next() + } +} +#[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_or_return(syntax: SyntaxNode) -> Result { + if Self::can_cast(syntax.kind()) { + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for BlockExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + BLOCK_EXPR => true, + _ => false, + } + } + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + if Self::can_cast_element(syntax.kind()) { + Ok(Self { syntax: syntax.into_node().unwrap() }) + } else { + Err(syntax) + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) + } +} +impl ast::AttrsOwner for BlockExpr {} +impl BlockExpr { + pub fn label(&self) -> Option