From 15a7b5dd0199fed80e4e093f25c44296924a5c08 Mon Sep 17 00:00:00 2001 From: Luca Barbieri Date: Fri, 3 Apr 2020 21:12:07 +0200 Subject: [PATCH 1/7] Fix warnings emitted when compiling as part of rustc --- crates/ra_parser/src/lib.rs | 2 ++ crates/ra_syntax/src/algo.rs | 2 +- crates/ra_syntax/src/lib.rs | 2 ++ 3 files changed, 5 insertions(+), 1 deletion(-) 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_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/lib.rs b/crates/ra_syntax/src/lib.rs index f0e16dc2bff0..ef167e0d1ea0 100644 --- a/crates/ra_syntax/src/lib.rs +++ b/crates/ra_syntax/src/lib.rs @@ -19,6 +19,8 @@ //! [RFC]: //! [Swift]: +#![allow(elided_lifetimes_in_paths)] + mod syntax_node; mod syntax_error; mod parsing; From fb9b51625ea74a315c1053d9b5dce336000bc953 Mon Sep 17 00:00:00 2001 From: Luca Barbieri Date: Fri, 3 Apr 2020 21:12:08 +0200 Subject: [PATCH 2/7] Add AstElement trait, generate tokens, support tokens in enums - Adds a new AstElement trait that is implemented by all generated node, token and enum structs - Overhauls the code generators to code-generate all tokens, and also enhances enums to support including tokens, node, and nested enums --- crates/ra_syntax/src/ast.rs | 114 +- crates/ra_syntax/src/ast/generated.rs | 10242 ++++++++++++++++++++++-- crates/ra_syntax/src/ast/tokens.rs | 62 +- xtask/src/codegen/gen_syntax.rs | 298 +- 4 files changed, 10018 insertions(+), 698 deletions(-) diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs index 26fafb469a96..1ac0201b8135 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( diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs index 7204ca5b1724..9d7032ed7440 100644 --- a/crates/ra_syntax/src/ast/generated.rs +++ b/crates/ra_syntax/src/ast/generated.rs @@ -1,11 +1,5501 @@ //! 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 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 AstToken for Semi { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + SEMI => 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 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 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 AstToken for Comma { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + COMMA => 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 Comma { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + COMMA => 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 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 AstToken for LParen { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + L_PAREN => 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 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 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 AstToken for RParen { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + R_PAREN => 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 RParen { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + R_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 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 AstToken for LCurly { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + L_CURLY => 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 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 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 AstToken for RCurly { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + R_CURLY => 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 RCurly { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + R_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 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 AstToken for LBrack { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + L_BRACK => 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 LBrack { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + L_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 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 AstToken for RBrack { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + R_BRACK => 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 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 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 AstToken for LAngle { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + L_ANGLE => 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 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 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 AstToken for RAngle { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + R_ANGLE => 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 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 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 AstToken for At { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + AT => 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 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 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 AstToken for Pound { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + POUND => 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 Pound { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + POUND => 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 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 AstToken for Tilde { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + TILDE => 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 Tilde { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TILDE => 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 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 AstToken for Question { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + QUESTION => 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 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 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 AstToken for Dollar { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + 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 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 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 AstToken for Amp { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + AMP => 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 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 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 AstToken for Pipe { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + PIPE => 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 Pipe { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + PIPE => 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 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 AstToken for Plus { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + PLUS => 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 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 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 AstToken for Star { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + STAR => 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 Star { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + STAR => 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 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 AstToken for Slash { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + SLASH => 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 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 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 AstToken for Caret { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + CARET => 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 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 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 AstToken for Percent { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + PERCENT => 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 Percent { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + PERCENT => 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 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 AstToken for Underscore { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + UNDERSCORE => 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 Underscore { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + UNDERSCORE => 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 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 AstToken for Dot { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + DOT => 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 Dot { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + DOT => 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 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 AstToken for Dotdot { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + DOTDOT => 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 Dotdot { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + DOTDOT => 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 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 AstToken for Dotdotdot { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + DOTDOTDOT => 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 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 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 AstToken for Dotdoteq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + DOTDOTEQ => 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 Dotdoteq { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + DOTDOTEQ => 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 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 AstToken for Colon { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + COLON => 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 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 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 AstToken for Coloncolon { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + COLONCOLON => 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 Coloncolon { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + COLONCOLON => 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 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 AstToken for Eq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + EQ => 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 Eq { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + EQ => 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 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 AstToken for Eqeq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + EQEQ => 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 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 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 AstToken for FatArrow { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + FAT_ARROW => 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 FatArrow { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + FAT_ARROW => 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 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 AstToken for Excl { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + EXCL => 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 Excl { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + EXCL => 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 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 AstToken for Neq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + NEQ => 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 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 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 AstToken for Minus { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + MINUS => 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 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 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 AstToken for ThinArrow { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + THIN_ARROW => 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 ThinArrow { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + THIN_ARROW => 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 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 AstToken for Lteq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + LTEQ => 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 Lteq { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + LTEQ => 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 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 AstToken for Gteq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + GTEQ => 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 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 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 AstToken for Pluseq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + PLUSEQ => 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 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 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 AstToken for Minuseq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + MINUSEQ => 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 Minuseq { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + MINUSEQ => 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 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 AstToken for Pipeeq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + PIPEEQ => 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 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 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 AstToken for Ampeq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + AMPEQ => 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 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 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 AstToken for Careteq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + CARETEQ => 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 Careteq { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + CARETEQ => 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 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 AstToken for Slasheq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + SLASHEQ => 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 Slasheq { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + SLASHEQ => 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 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 AstToken for Stareq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + STAREQ => 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 Stareq { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + STAREQ => 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 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 AstToken for Percenteq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + PERCENTEQ => 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 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 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 AstToken for Ampamp { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + AMPAMP => 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 Ampamp { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + AMPAMP => 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 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 AstToken for Pipepipe { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + PIPEPIPE => 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 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 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 AstToken for Shl { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + SHL => 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 Shl { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + SHL => 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 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 AstToken for Shr { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + SHR => 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 Shr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + SHR => 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 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 AstToken for Shleq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + SHLEQ => 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 Shleq { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + SHLEQ => 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 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 AstToken for Shreq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + SHREQ => 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 Shreq { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + SHREQ => 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 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 AstToken for AsKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + AS_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 AsKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + AS_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 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 AstToken for AsyncKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + ASYNC_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 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 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 AstToken for AwaitKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + AWAIT_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 AwaitKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + AWAIT_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 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 AstToken for BoxKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + BOX_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 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 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 AstToken for BreakKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + BREAK_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 BreakKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + BREAK_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 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 AstToken for ConstKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + CONST_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 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 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 AstToken for ContinueKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + CONTINUE_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 ContinueKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + CONTINUE_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 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 AstToken for CrateKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + CRATE_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 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) + } + } + 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 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 AstToken for DynKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + DYN_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 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 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 AstToken for ElseKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + ELSE_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 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) + } + } + 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 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 AstToken for EnumKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + ENUM_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 EnumKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + ENUM_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 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 AstToken for ExternKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + EXTERN_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 ExternKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + EXTERN_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 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 AstToken for FalseKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + FALSE_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 FalseKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + FALSE_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 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 AstToken for FnKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + FN_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 FnKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + FN_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 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 AstToken for ForKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + FOR_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 ForKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + FOR_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 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 AstToken for IfKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + IF_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 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 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 AstToken for ImplKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + IMPL_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 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 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 AstToken for InKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + IN_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 InKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + IN_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 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 AstToken for LetKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + LET_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 LetKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + LET_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 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 AstToken for LoopKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + LOOP_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 LoopKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + LOOP_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 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 AstToken for MacroKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + MACRO_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 MacroKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + MACRO_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 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 AstToken for MatchKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + MATCH_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 MatchKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + MATCH_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 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 AstToken for ModKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + MOD_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 ModKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + MOD_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 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 AstToken for MoveKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + MOVE_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 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) + } + } + 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 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 AstToken for MutKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + MUT_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 MutKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + MUT_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 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 AstToken for PubKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + PUB_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 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 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 AstToken for RefKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + REF_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 RefKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + REF_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 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 AstToken for ReturnKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + RETURN_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 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 AstToken for SelfKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + SELF_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 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 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 AstToken for StaticKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + STATIC_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 StaticKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + STATIC_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 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 AstToken for StructKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + STRUCT_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 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 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 AstToken for SuperKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + SUPER_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 SuperKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + SUPER_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 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 AstToken for TraitKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + TRAIT_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 TraitKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TRAIT_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 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 AstToken for TrueKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + TRUE_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 TrueKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TRUE_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 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 AstToken for TryKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + TRY_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 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 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 AstToken for TypeKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + TYPE_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 TypeKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TYPE_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 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 AstToken for UnsafeKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + UNSAFE_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 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) + } +} +#[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 AstToken for UseKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + USE_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 UseKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + USE_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 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 AstToken for WhereKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + WHERE_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 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) + } +} +#[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 AstToken for WhileKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + WHILE_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 WhileKw { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + WHILE_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 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 AstToken for AutoKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + AUTO_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 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 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, } @@ -21,16 +5511,40 @@ impl AstNode for SourceFile { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 {} @@ -55,16 +5569,40 @@ impl AstNode for FnDef { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 {} @@ -98,16 +5636,40 @@ impl AstNode for RetType { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 type_ref(&self) -> Option { @@ -130,15 +5692,39 @@ impl AstNode for StructDef { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + 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 { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.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 {} @@ -163,16 +5749,40 @@ impl AstNode for UnionDef { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 {} @@ -200,16 +5810,40 @@ impl AstNode for RecordFieldDefList { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 fields(&self) -> AstChildren { @@ -232,16 +5866,40 @@ impl AstNode for RecordFieldDef { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 {} @@ -265,16 +5923,40 @@ impl AstNode for TupleFieldDefList { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 fields(&self) -> AstChildren { @@ -297,16 +5979,40 @@ impl AstNode for TupleFieldDef { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 {} @@ -331,16 +6037,40 @@ impl AstNode for EnumDef { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 {} @@ -368,16 +6098,40 @@ impl AstNode for EnumVariantList { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 variants(&self) -> AstChildren { @@ -400,16 +6154,40 @@ impl AstNode for EnumVariant { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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::NameOwner for EnumVariant {} impl ast::DocCommentsOwner for EnumVariant {} @@ -435,16 +6213,40 @@ impl AstNode for TraitDef { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 {} @@ -473,16 +6275,40 @@ impl AstNode for Module { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 {} @@ -509,16 +6335,40 @@ impl AstNode for ItemList { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 {} @@ -543,16 +6393,40 @@ impl AstNode for ConstDef { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 {} @@ -581,16 +6455,40 @@ impl AstNode for StaticDef { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 {} @@ -619,16 +6517,40 @@ impl AstNode for TypeAliasDef { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 {} @@ -657,16 +6579,40 @@ impl AstNode for ImplDef { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 {} @@ -691,16 +6637,40 @@ impl AstNode for ParenType { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 type_ref(&self) -> Option { @@ -723,16 +6693,40 @@ impl AstNode for TupleType { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 fields(&self) -> AstChildren { @@ -755,16 +6749,40 @@ impl AstNode for NeverType { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -783,16 +6801,40 @@ impl AstNode for PathType { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 { @@ -815,16 +6857,40 @@ impl AstNode for PointerType { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 type_ref(&self) -> Option { @@ -847,15 +6913,39 @@ impl AstNode for ArrayType { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + 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 { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) } } impl ArrayType { @@ -882,16 +6972,40 @@ impl AstNode for SliceType { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 type_ref(&self) -> Option { @@ -914,16 +7028,40 @@ impl AstNode for ReferenceType { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 type_ref(&self) -> Option { @@ -946,16 +7084,40 @@ impl AstNode for PlaceholderType { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -974,16 +7136,40 @@ impl AstNode for FnPointerType { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 param_list(&self) -> Option { @@ -1009,16 +7195,40 @@ impl AstNode for ForType { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 type_ref(&self) -> Option { @@ -1041,16 +7251,40 @@ impl AstNode for ImplTraitType { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 {} @@ -1070,16 +7304,40 @@ impl AstNode for DynTraitType { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 {} @@ -1099,16 +7357,40 @@ impl AstNode for TupleExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 TupleExpr { pub fn exprs(&self) -> AstChildren { @@ -1131,16 +7413,40 @@ impl AstNode for ArrayExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 ArrayExpr { pub fn exprs(&self) -> AstChildren { @@ -1163,16 +7469,40 @@ impl AstNode for ParenExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 ParenExpr { pub fn expr(&self) -> Option { @@ -1195,16 +7525,40 @@ impl AstNode for PathExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 { @@ -1227,16 +7581,40 @@ impl AstNode for LambdaExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 LambdaExpr { pub fn param_list(&self) -> Option { @@ -1265,16 +7643,40 @@ impl AstNode for IfExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 IfExpr { pub fn condition(&self) -> Option { @@ -1297,16 +7699,40 @@ impl AstNode for LoopExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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::LoopBodyOwner for LoopExpr {} impl LoopExpr {} @@ -1326,16 +7752,40 @@ impl AstNode for TryBlockExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 TryBlockExpr { pub fn body(&self) -> Option { @@ -1358,16 +7808,40 @@ impl AstNode for ForExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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::LoopBodyOwner for ForExpr {} impl ForExpr { @@ -1394,16 +7868,40 @@ impl AstNode for WhileExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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::LoopBodyOwner for WhileExpr {} impl WhileExpr { @@ -1427,16 +7925,40 @@ impl AstNode for ContinueExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 ContinueExpr {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -1455,16 +7977,40 @@ impl AstNode for BreakExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 BreakExpr { pub fn expr(&self) -> Option { @@ -1487,16 +8033,40 @@ impl AstNode for Label { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + 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 {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -1515,15 +8085,39 @@ impl AstNode for BlockExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + 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 { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) } } impl BlockExpr { @@ -1547,16 +8141,40 @@ impl AstNode for ReturnExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for ReturnExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + RETURN_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 ReturnExpr { pub fn expr(&self) -> Option { @@ -1579,16 +8197,40 @@ impl AstNode for CallExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for CallExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + CALL_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::ArgListOwner for CallExpr {} impl CallExpr { @@ -1612,16 +8254,40 @@ impl AstNode for MethodCallExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for MethodCallExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + METHOD_CALL_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::ArgListOwner for MethodCallExpr {} impl MethodCallExpr { @@ -1651,16 +8317,40 @@ impl AstNode for IndexExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for IndexExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + INDEX_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 IndexExpr {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -1679,16 +8369,40 @@ impl AstNode for FieldExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for FieldExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + FIELD_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 FieldExpr { pub fn expr(&self) -> Option { @@ -1714,16 +8428,40 @@ impl AstNode for AwaitExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for AwaitExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + AWAIT_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 AwaitExpr { pub fn expr(&self) -> Option { @@ -1746,16 +8484,40 @@ impl AstNode for TryExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for TryExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TRY_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 TryExpr { pub fn expr(&self) -> Option { @@ -1778,16 +8540,40 @@ impl AstNode for CastExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for CastExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + CAST_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 CastExpr { pub fn expr(&self) -> Option { @@ -1813,16 +8599,40 @@ impl AstNode for RefExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for RefExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + REF_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 RefExpr { pub fn expr(&self) -> Option { @@ -1845,16 +8655,40 @@ impl AstNode for PrefixExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for PrefixExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + PREFIX_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 PrefixExpr { pub fn expr(&self) -> Option { @@ -1877,16 +8711,40 @@ impl AstNode for BoxExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for BoxExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + BOX_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 BoxExpr { pub fn expr(&self) -> Option { @@ -1909,16 +8767,40 @@ impl AstNode for RangeExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for RangeExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + RANGE_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 RangeExpr {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -1937,16 +8819,40 @@ impl AstNode for BinExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for BinExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + BIN_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 BinExpr {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -1965,16 +8871,40 @@ impl AstNode for Literal { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for Literal { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + LITERAL => 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 Literal {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -1993,16 +8923,40 @@ impl AstNode for MatchExpr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for MatchExpr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + MATCH_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 MatchExpr { pub fn expr(&self) -> Option { @@ -2028,16 +8982,40 @@ impl AstNode for MatchArmList { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for MatchArmList { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + MATCH_ARM_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::AttrsOwner for MatchArmList {} impl MatchArmList { @@ -2061,16 +9039,40 @@ impl AstNode for MatchArm { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for MatchArm { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + MATCH_ARM => 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 MatchArm {} impl MatchArm { @@ -2100,16 +9102,40 @@ impl AstNode for MatchGuard { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for MatchGuard { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + MATCH_GUARD => 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 MatchGuard { pub fn expr(&self) -> Option { @@ -2132,16 +9158,40 @@ impl AstNode for RecordLit { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for RecordLit { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + RECORD_LIT => 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 RecordLit { pub fn path(&self) -> Option { @@ -2167,16 +9217,40 @@ impl AstNode for RecordFieldList { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for RecordFieldList { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + RECORD_FIELD_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 RecordFieldList { pub fn fields(&self) -> AstChildren { @@ -2202,15 +9276,39 @@ impl AstNode for RecordField { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for RecordField { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + RECORD_FIELD => 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 { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) } } impl RecordField { @@ -2237,16 +9335,40 @@ impl AstNode for OrPat { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for OrPat { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + OR_PAT => 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 OrPat { pub fn pats(&self) -> AstChildren { @@ -2269,16 +9391,40 @@ impl AstNode for ParenPat { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for ParenPat { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + PAREN_PAT => 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 ParenPat { pub fn pat(&self) -> Option { @@ -2301,16 +9447,40 @@ impl AstNode for RefPat { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for RefPat { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + REF_PAT => 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 RefPat { pub fn pat(&self) -> Option { @@ -2333,16 +9503,40 @@ impl AstNode for BoxPat { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for BoxPat { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + BOX_PAT => 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 BoxPat { pub fn pat(&self) -> Option { @@ -2365,16 +9559,40 @@ impl AstNode for BindPat { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for BindPat { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + BIND_PAT => 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::NameOwner for BindPat {} impl BindPat { @@ -2398,16 +9616,40 @@ impl AstNode for PlaceholderPat { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for PlaceholderPat { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + PLACEHOLDER_PAT => 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 PlaceholderPat {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -2426,16 +9668,40 @@ impl AstNode for DotDotPat { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for DotDotPat { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + DOT_DOT_PAT => 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 DotDotPat {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -2454,16 +9720,40 @@ impl AstNode for PathPat { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for PathPat { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + PATH_PAT => 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 PathPat { pub fn path(&self) -> Option { @@ -2486,16 +9776,40 @@ impl AstNode for SlicePat { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for SlicePat { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + SLICE_PAT => 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 SlicePat { pub fn args(&self) -> AstChildren { @@ -2518,16 +9832,40 @@ impl AstNode for RangePat { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for RangePat { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + RANGE_PAT => 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 RangePat {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -2546,16 +9884,40 @@ impl AstNode for LiteralPat { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for LiteralPat { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + LITERAL_PAT => 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 LiteralPat { pub fn literal(&self) -> Option { @@ -2578,16 +9940,40 @@ impl AstNode for RecordPat { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for RecordPat { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + RECORD_PAT => 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 RecordPat { pub fn record_field_pat_list(&self) -> Option { @@ -2613,16 +9999,40 @@ impl AstNode for RecordFieldPatList { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for RecordFieldPatList { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + RECORD_FIELD_PAT_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 RecordFieldPatList { pub fn record_field_pats(&self) -> AstChildren { @@ -2648,16 +10058,40 @@ impl AstNode for RecordFieldPat { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for RecordFieldPat { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + RECORD_FIELD_PAT => 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::NameOwner for RecordFieldPat {} impl RecordFieldPat { @@ -2681,16 +10115,40 @@ impl AstNode for TupleStructPat { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for TupleStructPat { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TUPLE_STRUCT_PAT => 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 TupleStructPat { pub fn path(&self) -> Option { @@ -2716,16 +10174,40 @@ impl AstNode for TuplePat { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for TuplePat { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TUPLE_PAT => 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 TuplePat { pub fn args(&self) -> AstChildren { @@ -2748,16 +10230,40 @@ impl AstNode for Visibility { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for Visibility { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + VISIBILITY => 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 Visibility {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -2776,16 +10282,40 @@ impl AstNode for Name { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for Name { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + NAME => 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 Name {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -2804,16 +10334,40 @@ impl AstNode for NameRef { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for NameRef { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + NAME_REF => 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 NameRef {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -2832,16 +10386,40 @@ impl AstNode for MacroCall { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for MacroCall { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + MACRO_CALL => 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::NameOwner for MacroCall {} impl ast::AttrsOwner for MacroCall {} @@ -2870,15 +10448,39 @@ impl AstNode for Attr { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) + } else { + Err(syntax) + } + } + fn syntax(&self) -> &SyntaxNode { + &self.syntax + } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for Attr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + ATTR => 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 { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.syntax + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + NodeOrToken::Node(&self.syntax) + } + fn into_syntax_element(self) -> SyntaxElement { + NodeOrToken::Node(self.syntax) } } impl Attr { @@ -2905,16 +10507,40 @@ impl AstNode for TokenTree { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for TokenTree { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TOKEN_TREE => 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 TokenTree {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -2933,16 +10559,40 @@ impl AstNode for TypeParamList { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for TypeParamList { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TYPE_PARAM_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 TypeParamList { pub fn type_params(&self) -> AstChildren { @@ -2968,16 +10618,40 @@ impl AstNode for TypeParam { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for TypeParam { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TYPE_PARAM => 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::NameOwner for TypeParam {} impl ast::AttrsOwner for TypeParam {} @@ -3003,16 +10677,40 @@ impl AstNode for ConstParam { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for ConstParam { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + CONST_PARAM => 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::NameOwner for ConstParam {} impl ast::AttrsOwner for ConstParam {} @@ -3038,16 +10736,40 @@ impl AstNode for LifetimeParam { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for LifetimeParam { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + LIFETIME_PARAM => 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 LifetimeParam {} impl LifetimeParam {} @@ -3067,16 +10789,40 @@ impl AstNode for TypeBound { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for TypeBound { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TYPE_BOUND => 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 TypeBound { pub fn type_ref(&self) -> Option { @@ -3099,16 +10845,40 @@ impl AstNode for TypeBoundList { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for TypeBoundList { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TYPE_BOUND_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 TypeBoundList { pub fn bounds(&self) -> AstChildren { @@ -3131,16 +10901,40 @@ impl AstNode for WherePred { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for WherePred { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + WHERE_PRED => 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 WherePred {} impl WherePred { @@ -3164,16 +10958,40 @@ impl AstNode for WhereClause { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for WhereClause { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + WHERE_CLAUSE => 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 WhereClause { pub fn predicates(&self) -> AstChildren { @@ -3196,16 +11014,40 @@ impl AstNode for ExprStmt { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for ExprStmt { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + EXPR_STMT => 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 ExprStmt { pub fn expr(&self) -> Option { @@ -3228,16 +11070,40 @@ impl AstNode for LetStmt { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for LetStmt { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + LET_STMT => 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::TypeAscriptionOwner for LetStmt {} impl LetStmt { @@ -3264,16 +11130,40 @@ impl AstNode for Condition { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for Condition { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + CONDITION => 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 Condition { pub fn pat(&self) -> Option { @@ -3299,16 +11189,40 @@ impl AstNode for Block { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for Block { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + BLOCK => 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 Block {} impl ast::ModuleItemOwner for Block {} @@ -3336,16 +11250,40 @@ impl AstNode for ParamList { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for ParamList { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + PARAM_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 ParamList { pub fn self_param(&self) -> Option { @@ -3371,16 +11309,40 @@ impl AstNode for SelfParam { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for SelfParam { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + SELF_PARAM => 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::TypeAscriptionOwner for SelfParam {} impl ast::AttrsOwner for SelfParam {} @@ -3401,16 +11363,40 @@ impl AstNode for Param { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for Param { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + PARAM => 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::TypeAscriptionOwner for Param {} impl ast::AttrsOwner for Param {} @@ -3435,16 +11421,40 @@ impl AstNode for UseItem { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for UseItem { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + USE_ITEM => 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 UseItem {} impl ast::VisibilityOwner for UseItem {} @@ -3469,16 +11479,40 @@ impl AstNode for UseTree { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for UseTree { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + USE_TREE => 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 UseTree { pub fn path(&self) -> Option { @@ -3507,16 +11541,40 @@ impl AstNode for Alias { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for Alias { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + ALIAS => 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::NameOwner for Alias {} impl Alias {} @@ -3536,16 +11594,40 @@ impl AstNode for UseTreeList { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for UseTreeList { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + USE_TREE_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 UseTreeList { pub fn use_trees(&self) -> AstChildren { @@ -3568,15 +11650,39 @@ impl AstNode for ExternCrateItem { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + 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 ExternCrateItem { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + EXTERN_CRATE_ITEM => 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 { - None + Err(syntax) } } - fn syntax(&self) -> &SyntaxNode { - &self.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 ExternCrateItem {} @@ -3605,16 +11711,40 @@ impl AstNode for ArgList { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for ArgList { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + ARG_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 ArgList { pub fn args(&self) -> AstChildren { @@ -3637,16 +11767,40 @@ impl AstNode for Path { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for Path { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + PATH => 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 Path { pub fn segment(&self) -> Option { @@ -3672,16 +11826,40 @@ impl AstNode for PathSegment { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for PathSegment { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + PATH_SEGMENT => 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 PathSegment { pub fn name_ref(&self) -> Option { @@ -3716,16 +11894,40 @@ impl AstNode for TypeArgList { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for TypeArgList { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TYPE_ARG_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 TypeArgList { pub fn type_args(&self) -> AstChildren { @@ -3757,16 +11959,40 @@ impl AstNode for TypeArg { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for TypeArg { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + TYPE_ARG => 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 TypeArg { pub fn type_ref(&self) -> Option { @@ -3789,16 +12015,40 @@ impl AstNode for AssocTypeArg { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for AssocTypeArg { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + ASSOC_TYPE_ARG => 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 AssocTypeArg { pub fn name_ref(&self) -> Option { @@ -3824,16 +12074,40 @@ impl AstNode for LifetimeArg { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for LifetimeArg { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + LIFETIME_ARG => 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 LifetimeArg {} #[derive(Debug, Clone, PartialEq, Eq, Hash)] @@ -3852,16 +12126,40 @@ impl AstNode for ConstArg { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for ConstArg { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + CONST_ARG => 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 ConstArg { pub fn literal(&self) -> Option { @@ -3887,16 +12185,40 @@ impl AstNode for MacroItems { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for MacroItems { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + MACRO_ITEMS => 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 MacroItems {} impl ast::FnDefOwner for MacroItems {} @@ -3917,16 +12239,40 @@ impl AstNode for MacroStmts { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { + fn cast_or_return(syntax: SyntaxNode) -> Result { if Self::can_cast(syntax.kind()) { - Some(Self { syntax }) + Ok(Self { syntax }) } else { - None + Err(syntax) } } fn syntax(&self) -> &SyntaxNode { &self.syntax } + fn into_syntax(self) -> SyntaxNode { + self.syntax + } +} +impl AstElement for MacroStmts { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + MACRO_STMTS => 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 MacroStmts { pub fn statements(&self) -> AstChildren { @@ -3959,30 +12305,74 @@ impl From for NominalDef { } impl std::fmt::Display for NominalDef { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) + match self { + NominalDef::StructDef(it) => std::fmt::Display::fmt(it, f), + NominalDef::EnumDef(it) => std::fmt::Display::fmt(it, f), + NominalDef::UnionDef(it) => std::fmt::Display::fmt(it, f), + } } } impl AstNode for NominalDef { fn can_cast(kind: SyntaxKind) -> bool { match kind { - STRUCT_DEF | ENUM_DEF | UNION_DEF => true, + ENUM_DEF | STRUCT_DEF | UNION_DEF => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - let res = match syntax.kind() { - STRUCT_DEF => NominalDef::StructDef(StructDef { syntax }), - ENUM_DEF => NominalDef::EnumDef(EnumDef { syntax }), - UNION_DEF => NominalDef::UnionDef(UnionDef { syntax }), - _ => return None, - }; - Some(res) + #[allow(unreachable_patterns)] + fn cast_or_return(syntax: SyntaxNode) -> Result { + match syntax.kind() { + STRUCT_DEF => StructDef::cast_or_return(syntax).map(|x| NominalDef::StructDef(x)), + ENUM_DEF => EnumDef::cast_or_return(syntax).map(|x| NominalDef::EnumDef(x)), + UNION_DEF => UnionDef::cast_or_return(syntax).map(|x| NominalDef::UnionDef(x)), + _ => Err(syntax), + } } fn syntax(&self) -> &SyntaxNode { match self { - NominalDef::StructDef(it) => &it.syntax, - NominalDef::EnumDef(it) => &it.syntax, - NominalDef::UnionDef(it) => &it.syntax, + NominalDef::StructDef(it) => it.syntax(), + NominalDef::EnumDef(it) => it.syntax(), + NominalDef::UnionDef(it) => it.syntax(), + } + } + fn into_syntax(self) -> SyntaxNode { + match self { + NominalDef::StructDef(it) => it.into_syntax(), + NominalDef::EnumDef(it) => it.into_syntax(), + NominalDef::UnionDef(it) => it.into_syntax(), + } + } +} +impl AstElement for NominalDef { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + ENUM_DEF | STRUCT_DEF | UNION_DEF => true, + _ => false, + } + } + #[allow(unreachable_patterns)] + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + match syntax.kind() { + STRUCT_DEF => { + StructDef::cast_or_return_element(syntax).map(|x| NominalDef::StructDef(x)) + } + ENUM_DEF => EnumDef::cast_or_return_element(syntax).map(|x| NominalDef::EnumDef(x)), + UNION_DEF => UnionDef::cast_or_return_element(syntax).map(|x| NominalDef::UnionDef(x)), + _ => Err(syntax), + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + match self { + NominalDef::StructDef(it) => it.syntax_element(), + NominalDef::EnumDef(it) => it.syntax_element(), + NominalDef::UnionDef(it) => it.syntax_element(), + } + } + fn into_syntax_element(self) -> SyntaxElement { + match self { + NominalDef::StructDef(it) => it.into_syntax_element(), + NominalDef::EnumDef(it) => it.into_syntax_element(), + NominalDef::UnionDef(it) => it.into_syntax_element(), } } } @@ -4072,52 +12462,168 @@ impl From for TypeRef { } impl std::fmt::Display for TypeRef { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) + match self { + TypeRef::ParenType(it) => std::fmt::Display::fmt(it, f), + TypeRef::TupleType(it) => std::fmt::Display::fmt(it, f), + TypeRef::NeverType(it) => std::fmt::Display::fmt(it, f), + TypeRef::PathType(it) => std::fmt::Display::fmt(it, f), + TypeRef::PointerType(it) => std::fmt::Display::fmt(it, f), + TypeRef::ArrayType(it) => std::fmt::Display::fmt(it, f), + TypeRef::SliceType(it) => std::fmt::Display::fmt(it, f), + TypeRef::ReferenceType(it) => std::fmt::Display::fmt(it, f), + TypeRef::PlaceholderType(it) => std::fmt::Display::fmt(it, f), + TypeRef::FnPointerType(it) => std::fmt::Display::fmt(it, f), + TypeRef::ForType(it) => std::fmt::Display::fmt(it, f), + TypeRef::ImplTraitType(it) => std::fmt::Display::fmt(it, f), + TypeRef::DynTraitType(it) => std::fmt::Display::fmt(it, f), + } } } impl AstNode for TypeRef { fn can_cast(kind: SyntaxKind) -> bool { match kind { - PAREN_TYPE | TUPLE_TYPE | NEVER_TYPE | PATH_TYPE | POINTER_TYPE | ARRAY_TYPE - | SLICE_TYPE | REFERENCE_TYPE | PLACEHOLDER_TYPE | FN_POINTER_TYPE | FOR_TYPE - | IMPL_TRAIT_TYPE | DYN_TRAIT_TYPE => true, + ARRAY_TYPE | DYN_TRAIT_TYPE | FN_POINTER_TYPE | FOR_TYPE | IMPL_TRAIT_TYPE + | NEVER_TYPE | PAREN_TYPE | PATH_TYPE | PLACEHOLDER_TYPE | POINTER_TYPE + | REFERENCE_TYPE | SLICE_TYPE | TUPLE_TYPE => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - let res = match syntax.kind() { - PAREN_TYPE => TypeRef::ParenType(ParenType { syntax }), - TUPLE_TYPE => TypeRef::TupleType(TupleType { syntax }), - NEVER_TYPE => TypeRef::NeverType(NeverType { syntax }), - PATH_TYPE => TypeRef::PathType(PathType { syntax }), - POINTER_TYPE => TypeRef::PointerType(PointerType { syntax }), - ARRAY_TYPE => TypeRef::ArrayType(ArrayType { syntax }), - SLICE_TYPE => TypeRef::SliceType(SliceType { syntax }), - REFERENCE_TYPE => TypeRef::ReferenceType(ReferenceType { syntax }), - PLACEHOLDER_TYPE => TypeRef::PlaceholderType(PlaceholderType { syntax }), - FN_POINTER_TYPE => TypeRef::FnPointerType(FnPointerType { syntax }), - FOR_TYPE => TypeRef::ForType(ForType { syntax }), - IMPL_TRAIT_TYPE => TypeRef::ImplTraitType(ImplTraitType { syntax }), - DYN_TRAIT_TYPE => TypeRef::DynTraitType(DynTraitType { syntax }), - _ => return None, - }; - Some(res) + #[allow(unreachable_patterns)] + fn cast_or_return(syntax: SyntaxNode) -> Result { + match syntax.kind() { + PAREN_TYPE => ParenType::cast_or_return(syntax).map(|x| TypeRef::ParenType(x)), + TUPLE_TYPE => TupleType::cast_or_return(syntax).map(|x| TypeRef::TupleType(x)), + NEVER_TYPE => NeverType::cast_or_return(syntax).map(|x| TypeRef::NeverType(x)), + PATH_TYPE => PathType::cast_or_return(syntax).map(|x| TypeRef::PathType(x)), + POINTER_TYPE => PointerType::cast_or_return(syntax).map(|x| TypeRef::PointerType(x)), + ARRAY_TYPE => ArrayType::cast_or_return(syntax).map(|x| TypeRef::ArrayType(x)), + SLICE_TYPE => SliceType::cast_or_return(syntax).map(|x| TypeRef::SliceType(x)), + REFERENCE_TYPE => { + ReferenceType::cast_or_return(syntax).map(|x| TypeRef::ReferenceType(x)) + } + PLACEHOLDER_TYPE => { + PlaceholderType::cast_or_return(syntax).map(|x| TypeRef::PlaceholderType(x)) + } + FN_POINTER_TYPE => { + FnPointerType::cast_or_return(syntax).map(|x| TypeRef::FnPointerType(x)) + } + FOR_TYPE => ForType::cast_or_return(syntax).map(|x| TypeRef::ForType(x)), + IMPL_TRAIT_TYPE => { + ImplTraitType::cast_or_return(syntax).map(|x| TypeRef::ImplTraitType(x)) + } + DYN_TRAIT_TYPE => { + DynTraitType::cast_or_return(syntax).map(|x| TypeRef::DynTraitType(x)) + } + _ => Err(syntax), + } } fn syntax(&self) -> &SyntaxNode { match self { - TypeRef::ParenType(it) => &it.syntax, - TypeRef::TupleType(it) => &it.syntax, - TypeRef::NeverType(it) => &it.syntax, - TypeRef::PathType(it) => &it.syntax, - TypeRef::PointerType(it) => &it.syntax, - TypeRef::ArrayType(it) => &it.syntax, - TypeRef::SliceType(it) => &it.syntax, - TypeRef::ReferenceType(it) => &it.syntax, - TypeRef::PlaceholderType(it) => &it.syntax, - TypeRef::FnPointerType(it) => &it.syntax, - TypeRef::ForType(it) => &it.syntax, - TypeRef::ImplTraitType(it) => &it.syntax, - TypeRef::DynTraitType(it) => &it.syntax, + TypeRef::ParenType(it) => it.syntax(), + TypeRef::TupleType(it) => it.syntax(), + TypeRef::NeverType(it) => it.syntax(), + TypeRef::PathType(it) => it.syntax(), + TypeRef::PointerType(it) => it.syntax(), + TypeRef::ArrayType(it) => it.syntax(), + TypeRef::SliceType(it) => it.syntax(), + TypeRef::ReferenceType(it) => it.syntax(), + TypeRef::PlaceholderType(it) => it.syntax(), + TypeRef::FnPointerType(it) => it.syntax(), + TypeRef::ForType(it) => it.syntax(), + TypeRef::ImplTraitType(it) => it.syntax(), + TypeRef::DynTraitType(it) => it.syntax(), + } + } + fn into_syntax(self) -> SyntaxNode { + match self { + TypeRef::ParenType(it) => it.into_syntax(), + TypeRef::TupleType(it) => it.into_syntax(), + TypeRef::NeverType(it) => it.into_syntax(), + TypeRef::PathType(it) => it.into_syntax(), + TypeRef::PointerType(it) => it.into_syntax(), + TypeRef::ArrayType(it) => it.into_syntax(), + TypeRef::SliceType(it) => it.into_syntax(), + TypeRef::ReferenceType(it) => it.into_syntax(), + TypeRef::PlaceholderType(it) => it.into_syntax(), + TypeRef::FnPointerType(it) => it.into_syntax(), + TypeRef::ForType(it) => it.into_syntax(), + TypeRef::ImplTraitType(it) => it.into_syntax(), + TypeRef::DynTraitType(it) => it.into_syntax(), + } + } +} +impl AstElement for TypeRef { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + ARRAY_TYPE | DYN_TRAIT_TYPE | FN_POINTER_TYPE | FOR_TYPE | IMPL_TRAIT_TYPE + | NEVER_TYPE | PAREN_TYPE | PATH_TYPE | PLACEHOLDER_TYPE | POINTER_TYPE + | REFERENCE_TYPE | SLICE_TYPE | TUPLE_TYPE => true, + _ => false, + } + } + #[allow(unreachable_patterns)] + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + match syntax.kind() { + PAREN_TYPE => ParenType::cast_or_return_element(syntax).map(|x| TypeRef::ParenType(x)), + TUPLE_TYPE => TupleType::cast_or_return_element(syntax).map(|x| TypeRef::TupleType(x)), + NEVER_TYPE => NeverType::cast_or_return_element(syntax).map(|x| TypeRef::NeverType(x)), + PATH_TYPE => PathType::cast_or_return_element(syntax).map(|x| TypeRef::PathType(x)), + POINTER_TYPE => { + PointerType::cast_or_return_element(syntax).map(|x| TypeRef::PointerType(x)) + } + ARRAY_TYPE => ArrayType::cast_or_return_element(syntax).map(|x| TypeRef::ArrayType(x)), + SLICE_TYPE => SliceType::cast_or_return_element(syntax).map(|x| TypeRef::SliceType(x)), + REFERENCE_TYPE => { + ReferenceType::cast_or_return_element(syntax).map(|x| TypeRef::ReferenceType(x)) + } + PLACEHOLDER_TYPE => { + PlaceholderType::cast_or_return_element(syntax).map(|x| TypeRef::PlaceholderType(x)) + } + FN_POINTER_TYPE => { + FnPointerType::cast_or_return_element(syntax).map(|x| TypeRef::FnPointerType(x)) + } + FOR_TYPE => ForType::cast_or_return_element(syntax).map(|x| TypeRef::ForType(x)), + IMPL_TRAIT_TYPE => { + ImplTraitType::cast_or_return_element(syntax).map(|x| TypeRef::ImplTraitType(x)) + } + DYN_TRAIT_TYPE => { + DynTraitType::cast_or_return_element(syntax).map(|x| TypeRef::DynTraitType(x)) + } + _ => Err(syntax), + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + match self { + TypeRef::ParenType(it) => it.syntax_element(), + TypeRef::TupleType(it) => it.syntax_element(), + TypeRef::NeverType(it) => it.syntax_element(), + TypeRef::PathType(it) => it.syntax_element(), + TypeRef::PointerType(it) => it.syntax_element(), + TypeRef::ArrayType(it) => it.syntax_element(), + TypeRef::SliceType(it) => it.syntax_element(), + TypeRef::ReferenceType(it) => it.syntax_element(), + TypeRef::PlaceholderType(it) => it.syntax_element(), + TypeRef::FnPointerType(it) => it.syntax_element(), + TypeRef::ForType(it) => it.syntax_element(), + TypeRef::ImplTraitType(it) => it.syntax_element(), + TypeRef::DynTraitType(it) => it.syntax_element(), + } + } + fn into_syntax_element(self) -> SyntaxElement { + match self { + TypeRef::ParenType(it) => it.into_syntax_element(), + TypeRef::TupleType(it) => it.into_syntax_element(), + TypeRef::NeverType(it) => it.into_syntax_element(), + TypeRef::PathType(it) => it.into_syntax_element(), + TypeRef::PointerType(it) => it.into_syntax_element(), + TypeRef::ArrayType(it) => it.into_syntax_element(), + TypeRef::SliceType(it) => it.into_syntax_element(), + TypeRef::ReferenceType(it) => it.into_syntax_element(), + TypeRef::PlaceholderType(it) => it.into_syntax_element(), + TypeRef::FnPointerType(it) => it.into_syntax_element(), + TypeRef::ForType(it) => it.into_syntax_element(), + TypeRef::ImplTraitType(it) => it.into_syntax_element(), + TypeRef::DynTraitType(it) => it.into_syntax_element(), } } } @@ -4204,51 +12710,157 @@ impl From for ModuleItem { } impl std::fmt::Display for ModuleItem { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) + match self { + ModuleItem::StructDef(it) => std::fmt::Display::fmt(it, f), + ModuleItem::UnionDef(it) => std::fmt::Display::fmt(it, f), + ModuleItem::EnumDef(it) => std::fmt::Display::fmt(it, f), + ModuleItem::FnDef(it) => std::fmt::Display::fmt(it, f), + ModuleItem::TraitDef(it) => std::fmt::Display::fmt(it, f), + ModuleItem::TypeAliasDef(it) => std::fmt::Display::fmt(it, f), + ModuleItem::ImplDef(it) => std::fmt::Display::fmt(it, f), + ModuleItem::UseItem(it) => std::fmt::Display::fmt(it, f), + ModuleItem::ExternCrateItem(it) => std::fmt::Display::fmt(it, f), + ModuleItem::ConstDef(it) => std::fmt::Display::fmt(it, f), + ModuleItem::StaticDef(it) => std::fmt::Display::fmt(it, f), + ModuleItem::Module(it) => std::fmt::Display::fmt(it, f), + ModuleItem::MacroCall(it) => std::fmt::Display::fmt(it, f), + } } } impl AstNode for ModuleItem { fn can_cast(kind: SyntaxKind) -> bool { match kind { - STRUCT_DEF | UNION_DEF | ENUM_DEF | FN_DEF | TRAIT_DEF | TYPE_ALIAS_DEF | IMPL_DEF - | USE_ITEM | EXTERN_CRATE_ITEM | CONST_DEF | STATIC_DEF | MODULE | MACRO_CALL => true, + CONST_DEF | ENUM_DEF | EXTERN_CRATE_ITEM | FN_DEF | IMPL_DEF | MACRO_CALL | MODULE + | STATIC_DEF | STRUCT_DEF | TRAIT_DEF | TYPE_ALIAS_DEF | UNION_DEF | USE_ITEM => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - let res = match syntax.kind() { - STRUCT_DEF => ModuleItem::StructDef(StructDef { syntax }), - UNION_DEF => ModuleItem::UnionDef(UnionDef { syntax }), - ENUM_DEF => ModuleItem::EnumDef(EnumDef { syntax }), - FN_DEF => ModuleItem::FnDef(FnDef { syntax }), - TRAIT_DEF => ModuleItem::TraitDef(TraitDef { syntax }), - TYPE_ALIAS_DEF => ModuleItem::TypeAliasDef(TypeAliasDef { syntax }), - IMPL_DEF => ModuleItem::ImplDef(ImplDef { syntax }), - USE_ITEM => ModuleItem::UseItem(UseItem { syntax }), - EXTERN_CRATE_ITEM => ModuleItem::ExternCrateItem(ExternCrateItem { syntax }), - CONST_DEF => ModuleItem::ConstDef(ConstDef { syntax }), - STATIC_DEF => ModuleItem::StaticDef(StaticDef { syntax }), - MODULE => ModuleItem::Module(Module { syntax }), - MACRO_CALL => ModuleItem::MacroCall(MacroCall { syntax }), - _ => return None, - }; - Some(res) + #[allow(unreachable_patterns)] + fn cast_or_return(syntax: SyntaxNode) -> Result { + match syntax.kind() { + STRUCT_DEF => StructDef::cast_or_return(syntax).map(|x| ModuleItem::StructDef(x)), + UNION_DEF => UnionDef::cast_or_return(syntax).map(|x| ModuleItem::UnionDef(x)), + ENUM_DEF => EnumDef::cast_or_return(syntax).map(|x| ModuleItem::EnumDef(x)), + FN_DEF => FnDef::cast_or_return(syntax).map(|x| ModuleItem::FnDef(x)), + TRAIT_DEF => TraitDef::cast_or_return(syntax).map(|x| ModuleItem::TraitDef(x)), + TYPE_ALIAS_DEF => { + TypeAliasDef::cast_or_return(syntax).map(|x| ModuleItem::TypeAliasDef(x)) + } + IMPL_DEF => ImplDef::cast_or_return(syntax).map(|x| ModuleItem::ImplDef(x)), + USE_ITEM => UseItem::cast_or_return(syntax).map(|x| ModuleItem::UseItem(x)), + EXTERN_CRATE_ITEM => { + ExternCrateItem::cast_or_return(syntax).map(|x| ModuleItem::ExternCrateItem(x)) + } + CONST_DEF => ConstDef::cast_or_return(syntax).map(|x| ModuleItem::ConstDef(x)), + STATIC_DEF => StaticDef::cast_or_return(syntax).map(|x| ModuleItem::StaticDef(x)), + MODULE => Module::cast_or_return(syntax).map(|x| ModuleItem::Module(x)), + MACRO_CALL => MacroCall::cast_or_return(syntax).map(|x| ModuleItem::MacroCall(x)), + _ => Err(syntax), + } } fn syntax(&self) -> &SyntaxNode { match self { - ModuleItem::StructDef(it) => &it.syntax, - ModuleItem::UnionDef(it) => &it.syntax, - ModuleItem::EnumDef(it) => &it.syntax, - ModuleItem::FnDef(it) => &it.syntax, - ModuleItem::TraitDef(it) => &it.syntax, - ModuleItem::TypeAliasDef(it) => &it.syntax, - ModuleItem::ImplDef(it) => &it.syntax, - ModuleItem::UseItem(it) => &it.syntax, - ModuleItem::ExternCrateItem(it) => &it.syntax, - ModuleItem::ConstDef(it) => &it.syntax, - ModuleItem::StaticDef(it) => &it.syntax, - ModuleItem::Module(it) => &it.syntax, - ModuleItem::MacroCall(it) => &it.syntax, + ModuleItem::StructDef(it) => it.syntax(), + ModuleItem::UnionDef(it) => it.syntax(), + ModuleItem::EnumDef(it) => it.syntax(), + ModuleItem::FnDef(it) => it.syntax(), + ModuleItem::TraitDef(it) => it.syntax(), + ModuleItem::TypeAliasDef(it) => it.syntax(), + ModuleItem::ImplDef(it) => it.syntax(), + ModuleItem::UseItem(it) => it.syntax(), + ModuleItem::ExternCrateItem(it) => it.syntax(), + ModuleItem::ConstDef(it) => it.syntax(), + ModuleItem::StaticDef(it) => it.syntax(), + ModuleItem::Module(it) => it.syntax(), + ModuleItem::MacroCall(it) => it.syntax(), + } + } + fn into_syntax(self) -> SyntaxNode { + match self { + ModuleItem::StructDef(it) => it.into_syntax(), + ModuleItem::UnionDef(it) => it.into_syntax(), + ModuleItem::EnumDef(it) => it.into_syntax(), + ModuleItem::FnDef(it) => it.into_syntax(), + ModuleItem::TraitDef(it) => it.into_syntax(), + ModuleItem::TypeAliasDef(it) => it.into_syntax(), + ModuleItem::ImplDef(it) => it.into_syntax(), + ModuleItem::UseItem(it) => it.into_syntax(), + ModuleItem::ExternCrateItem(it) => it.into_syntax(), + ModuleItem::ConstDef(it) => it.into_syntax(), + ModuleItem::StaticDef(it) => it.into_syntax(), + ModuleItem::Module(it) => it.into_syntax(), + ModuleItem::MacroCall(it) => it.into_syntax(), + } + } +} +impl AstElement for ModuleItem { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + CONST_DEF | ENUM_DEF | EXTERN_CRATE_ITEM | FN_DEF | IMPL_DEF | MACRO_CALL | MODULE + | STATIC_DEF | STRUCT_DEF | TRAIT_DEF | TYPE_ALIAS_DEF | UNION_DEF | USE_ITEM => true, + _ => false, + } + } + #[allow(unreachable_patterns)] + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + match syntax.kind() { + STRUCT_DEF => { + StructDef::cast_or_return_element(syntax).map(|x| ModuleItem::StructDef(x)) + } + UNION_DEF => UnionDef::cast_or_return_element(syntax).map(|x| ModuleItem::UnionDef(x)), + ENUM_DEF => EnumDef::cast_or_return_element(syntax).map(|x| ModuleItem::EnumDef(x)), + FN_DEF => FnDef::cast_or_return_element(syntax).map(|x| ModuleItem::FnDef(x)), + TRAIT_DEF => TraitDef::cast_or_return_element(syntax).map(|x| ModuleItem::TraitDef(x)), + TYPE_ALIAS_DEF => { + TypeAliasDef::cast_or_return_element(syntax).map(|x| ModuleItem::TypeAliasDef(x)) + } + IMPL_DEF => ImplDef::cast_or_return_element(syntax).map(|x| ModuleItem::ImplDef(x)), + USE_ITEM => UseItem::cast_or_return_element(syntax).map(|x| ModuleItem::UseItem(x)), + EXTERN_CRATE_ITEM => ExternCrateItem::cast_or_return_element(syntax) + .map(|x| ModuleItem::ExternCrateItem(x)), + CONST_DEF => ConstDef::cast_or_return_element(syntax).map(|x| ModuleItem::ConstDef(x)), + STATIC_DEF => { + StaticDef::cast_or_return_element(syntax).map(|x| ModuleItem::StaticDef(x)) + } + MODULE => Module::cast_or_return_element(syntax).map(|x| ModuleItem::Module(x)), + MACRO_CALL => { + MacroCall::cast_or_return_element(syntax).map(|x| ModuleItem::MacroCall(x)) + } + _ => Err(syntax), + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + match self { + ModuleItem::StructDef(it) => it.syntax_element(), + ModuleItem::UnionDef(it) => it.syntax_element(), + ModuleItem::EnumDef(it) => it.syntax_element(), + ModuleItem::FnDef(it) => it.syntax_element(), + ModuleItem::TraitDef(it) => it.syntax_element(), + ModuleItem::TypeAliasDef(it) => it.syntax_element(), + ModuleItem::ImplDef(it) => it.syntax_element(), + ModuleItem::UseItem(it) => it.syntax_element(), + ModuleItem::ExternCrateItem(it) => it.syntax_element(), + ModuleItem::ConstDef(it) => it.syntax_element(), + ModuleItem::StaticDef(it) => it.syntax_element(), + ModuleItem::Module(it) => it.syntax_element(), + ModuleItem::MacroCall(it) => it.syntax_element(), + } + } + fn into_syntax_element(self) -> SyntaxElement { + match self { + ModuleItem::StructDef(it) => it.into_syntax_element(), + ModuleItem::UnionDef(it) => it.into_syntax_element(), + ModuleItem::EnumDef(it) => it.into_syntax_element(), + ModuleItem::FnDef(it) => it.into_syntax_element(), + ModuleItem::TraitDef(it) => it.into_syntax_element(), + ModuleItem::TypeAliasDef(it) => it.into_syntax_element(), + ModuleItem::ImplDef(it) => it.into_syntax_element(), + ModuleItem::UseItem(it) => it.into_syntax_element(), + ModuleItem::ExternCrateItem(it) => it.into_syntax_element(), + ModuleItem::ConstDef(it) => it.into_syntax_element(), + ModuleItem::StaticDef(it) => it.into_syntax_element(), + ModuleItem::Module(it) => it.into_syntax_element(), + ModuleItem::MacroCall(it) => it.into_syntax_element(), } } } @@ -4277,30 +12889,76 @@ impl From for ImplItem { } impl std::fmt::Display for ImplItem { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) + match self { + ImplItem::FnDef(it) => std::fmt::Display::fmt(it, f), + ImplItem::TypeAliasDef(it) => std::fmt::Display::fmt(it, f), + ImplItem::ConstDef(it) => std::fmt::Display::fmt(it, f), + } } } impl AstNode for ImplItem { fn can_cast(kind: SyntaxKind) -> bool { match kind { - FN_DEF | TYPE_ALIAS_DEF | CONST_DEF => true, + CONST_DEF | FN_DEF | TYPE_ALIAS_DEF => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - let res = match syntax.kind() { - FN_DEF => ImplItem::FnDef(FnDef { syntax }), - TYPE_ALIAS_DEF => ImplItem::TypeAliasDef(TypeAliasDef { syntax }), - CONST_DEF => ImplItem::ConstDef(ConstDef { syntax }), - _ => return None, - }; - Some(res) + #[allow(unreachable_patterns)] + fn cast_or_return(syntax: SyntaxNode) -> Result { + match syntax.kind() { + FN_DEF => FnDef::cast_or_return(syntax).map(|x| ImplItem::FnDef(x)), + TYPE_ALIAS_DEF => { + TypeAliasDef::cast_or_return(syntax).map(|x| ImplItem::TypeAliasDef(x)) + } + CONST_DEF => ConstDef::cast_or_return(syntax).map(|x| ImplItem::ConstDef(x)), + _ => Err(syntax), + } } fn syntax(&self) -> &SyntaxNode { match self { - ImplItem::FnDef(it) => &it.syntax, - ImplItem::TypeAliasDef(it) => &it.syntax, - ImplItem::ConstDef(it) => &it.syntax, + ImplItem::FnDef(it) => it.syntax(), + ImplItem::TypeAliasDef(it) => it.syntax(), + ImplItem::ConstDef(it) => it.syntax(), + } + } + fn into_syntax(self) -> SyntaxNode { + match self { + ImplItem::FnDef(it) => it.into_syntax(), + ImplItem::TypeAliasDef(it) => it.into_syntax(), + ImplItem::ConstDef(it) => it.into_syntax(), + } + } +} +impl AstElement for ImplItem { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + CONST_DEF | FN_DEF | TYPE_ALIAS_DEF => true, + _ => false, + } + } + #[allow(unreachable_patterns)] + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + match syntax.kind() { + FN_DEF => FnDef::cast_or_return_element(syntax).map(|x| ImplItem::FnDef(x)), + TYPE_ALIAS_DEF => { + TypeAliasDef::cast_or_return_element(syntax).map(|x| ImplItem::TypeAliasDef(x)) + } + CONST_DEF => ConstDef::cast_or_return_element(syntax).map(|x| ImplItem::ConstDef(x)), + _ => Err(syntax), + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + match self { + ImplItem::FnDef(it) => it.syntax_element(), + ImplItem::TypeAliasDef(it) => it.syntax_element(), + ImplItem::ConstDef(it) => it.syntax_element(), + } + } + fn into_syntax_element(self) -> SyntaxElement { + match self { + ImplItem::FnDef(it) => it.into_syntax_element(), + ImplItem::TypeAliasDef(it) => it.into_syntax_element(), + ImplItem::ConstDef(it) => it.into_syntax_element(), } } } @@ -4496,91 +13154,284 @@ impl From for Expr { } impl std::fmt::Display for Expr { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) + match self { + Expr::TupleExpr(it) => std::fmt::Display::fmt(it, f), + Expr::ArrayExpr(it) => std::fmt::Display::fmt(it, f), + Expr::ParenExpr(it) => std::fmt::Display::fmt(it, f), + Expr::PathExpr(it) => std::fmt::Display::fmt(it, f), + Expr::LambdaExpr(it) => std::fmt::Display::fmt(it, f), + Expr::IfExpr(it) => std::fmt::Display::fmt(it, f), + Expr::LoopExpr(it) => std::fmt::Display::fmt(it, f), + Expr::ForExpr(it) => std::fmt::Display::fmt(it, f), + Expr::WhileExpr(it) => std::fmt::Display::fmt(it, f), + Expr::ContinueExpr(it) => std::fmt::Display::fmt(it, f), + Expr::BreakExpr(it) => std::fmt::Display::fmt(it, f), + Expr::Label(it) => std::fmt::Display::fmt(it, f), + Expr::BlockExpr(it) => std::fmt::Display::fmt(it, f), + Expr::ReturnExpr(it) => std::fmt::Display::fmt(it, f), + Expr::MatchExpr(it) => std::fmt::Display::fmt(it, f), + Expr::RecordLit(it) => std::fmt::Display::fmt(it, f), + Expr::CallExpr(it) => std::fmt::Display::fmt(it, f), + Expr::IndexExpr(it) => std::fmt::Display::fmt(it, f), + Expr::MethodCallExpr(it) => std::fmt::Display::fmt(it, f), + Expr::FieldExpr(it) => std::fmt::Display::fmt(it, f), + Expr::AwaitExpr(it) => std::fmt::Display::fmt(it, f), + Expr::TryExpr(it) => std::fmt::Display::fmt(it, f), + Expr::TryBlockExpr(it) => std::fmt::Display::fmt(it, f), + Expr::CastExpr(it) => std::fmt::Display::fmt(it, f), + Expr::RefExpr(it) => std::fmt::Display::fmt(it, f), + Expr::PrefixExpr(it) => std::fmt::Display::fmt(it, f), + Expr::RangeExpr(it) => std::fmt::Display::fmt(it, f), + Expr::BinExpr(it) => std::fmt::Display::fmt(it, f), + Expr::Literal(it) => std::fmt::Display::fmt(it, f), + Expr::MacroCall(it) => std::fmt::Display::fmt(it, f), + Expr::BoxExpr(it) => std::fmt::Display::fmt(it, f), + } } } impl AstNode for Expr { fn can_cast(kind: SyntaxKind) -> bool { match kind { - TUPLE_EXPR | ARRAY_EXPR | PAREN_EXPR | PATH_EXPR | LAMBDA_EXPR | IF_EXPR - | LOOP_EXPR | FOR_EXPR | WHILE_EXPR | CONTINUE_EXPR | BREAK_EXPR | LABEL - | BLOCK_EXPR | RETURN_EXPR | MATCH_EXPR | RECORD_LIT | CALL_EXPR | INDEX_EXPR - | METHOD_CALL_EXPR | FIELD_EXPR | AWAIT_EXPR | TRY_EXPR | TRY_BLOCK_EXPR - | CAST_EXPR | REF_EXPR | PREFIX_EXPR | RANGE_EXPR | BIN_EXPR | LITERAL | MACRO_CALL - | BOX_EXPR => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - let res = match syntax.kind() { - TUPLE_EXPR => Expr::TupleExpr(TupleExpr { syntax }), - ARRAY_EXPR => Expr::ArrayExpr(ArrayExpr { syntax }), - PAREN_EXPR => Expr::ParenExpr(ParenExpr { syntax }), - PATH_EXPR => Expr::PathExpr(PathExpr { syntax }), - LAMBDA_EXPR => Expr::LambdaExpr(LambdaExpr { syntax }), - IF_EXPR => Expr::IfExpr(IfExpr { syntax }), - LOOP_EXPR => Expr::LoopExpr(LoopExpr { syntax }), - FOR_EXPR => Expr::ForExpr(ForExpr { syntax }), - WHILE_EXPR => Expr::WhileExpr(WhileExpr { syntax }), - CONTINUE_EXPR => Expr::ContinueExpr(ContinueExpr { syntax }), - BREAK_EXPR => Expr::BreakExpr(BreakExpr { syntax }), - LABEL => Expr::Label(Label { syntax }), - BLOCK_EXPR => Expr::BlockExpr(BlockExpr { syntax }), - RETURN_EXPR => Expr::ReturnExpr(ReturnExpr { syntax }), - MATCH_EXPR => Expr::MatchExpr(MatchExpr { syntax }), - RECORD_LIT => Expr::RecordLit(RecordLit { syntax }), - CALL_EXPR => Expr::CallExpr(CallExpr { syntax }), - INDEX_EXPR => Expr::IndexExpr(IndexExpr { syntax }), - METHOD_CALL_EXPR => Expr::MethodCallExpr(MethodCallExpr { syntax }), - FIELD_EXPR => Expr::FieldExpr(FieldExpr { syntax }), - AWAIT_EXPR => Expr::AwaitExpr(AwaitExpr { syntax }), - TRY_EXPR => Expr::TryExpr(TryExpr { syntax }), - TRY_BLOCK_EXPR => Expr::TryBlockExpr(TryBlockExpr { syntax }), - CAST_EXPR => Expr::CastExpr(CastExpr { syntax }), - REF_EXPR => Expr::RefExpr(RefExpr { syntax }), - PREFIX_EXPR => Expr::PrefixExpr(PrefixExpr { syntax }), - RANGE_EXPR => Expr::RangeExpr(RangeExpr { syntax }), - BIN_EXPR => Expr::BinExpr(BinExpr { syntax }), - LITERAL => Expr::Literal(Literal { syntax }), - MACRO_CALL => Expr::MacroCall(MacroCall { syntax }), - BOX_EXPR => Expr::BoxExpr(BoxExpr { syntax }), - _ => return None, - }; - Some(res) + ARRAY_EXPR | AWAIT_EXPR | BIN_EXPR | BLOCK_EXPR | BOX_EXPR | BREAK_EXPR | CALL_EXPR + | CAST_EXPR | CONTINUE_EXPR | FIELD_EXPR | FOR_EXPR | IF_EXPR | INDEX_EXPR | LABEL + | LAMBDA_EXPR | LITERAL | LOOP_EXPR | MACRO_CALL | MATCH_EXPR | METHOD_CALL_EXPR + | PAREN_EXPR | PATH_EXPR | PREFIX_EXPR | RANGE_EXPR | RECORD_LIT | REF_EXPR + | RETURN_EXPR | TRY_BLOCK_EXPR | TRY_EXPR | TUPLE_EXPR | WHILE_EXPR => true, + _ => false, + } + } + #[allow(unreachable_patterns)] + fn cast_or_return(syntax: SyntaxNode) -> Result { + match syntax.kind() { + TUPLE_EXPR => TupleExpr::cast_or_return(syntax).map(|x| Expr::TupleExpr(x)), + ARRAY_EXPR => ArrayExpr::cast_or_return(syntax).map(|x| Expr::ArrayExpr(x)), + PAREN_EXPR => ParenExpr::cast_or_return(syntax).map(|x| Expr::ParenExpr(x)), + PATH_EXPR => PathExpr::cast_or_return(syntax).map(|x| Expr::PathExpr(x)), + LAMBDA_EXPR => LambdaExpr::cast_or_return(syntax).map(|x| Expr::LambdaExpr(x)), + IF_EXPR => IfExpr::cast_or_return(syntax).map(|x| Expr::IfExpr(x)), + LOOP_EXPR => LoopExpr::cast_or_return(syntax).map(|x| Expr::LoopExpr(x)), + FOR_EXPR => ForExpr::cast_or_return(syntax).map(|x| Expr::ForExpr(x)), + WHILE_EXPR => WhileExpr::cast_or_return(syntax).map(|x| Expr::WhileExpr(x)), + CONTINUE_EXPR => ContinueExpr::cast_or_return(syntax).map(|x| Expr::ContinueExpr(x)), + BREAK_EXPR => BreakExpr::cast_or_return(syntax).map(|x| Expr::BreakExpr(x)), + LABEL => Label::cast_or_return(syntax).map(|x| Expr::Label(x)), + BLOCK_EXPR => BlockExpr::cast_or_return(syntax).map(|x| Expr::BlockExpr(x)), + RETURN_EXPR => ReturnExpr::cast_or_return(syntax).map(|x| Expr::ReturnExpr(x)), + MATCH_EXPR => MatchExpr::cast_or_return(syntax).map(|x| Expr::MatchExpr(x)), + RECORD_LIT => RecordLit::cast_or_return(syntax).map(|x| Expr::RecordLit(x)), + CALL_EXPR => CallExpr::cast_or_return(syntax).map(|x| Expr::CallExpr(x)), + INDEX_EXPR => IndexExpr::cast_or_return(syntax).map(|x| Expr::IndexExpr(x)), + METHOD_CALL_EXPR => { + MethodCallExpr::cast_or_return(syntax).map(|x| Expr::MethodCallExpr(x)) + } + FIELD_EXPR => FieldExpr::cast_or_return(syntax).map(|x| Expr::FieldExpr(x)), + AWAIT_EXPR => AwaitExpr::cast_or_return(syntax).map(|x| Expr::AwaitExpr(x)), + TRY_EXPR => TryExpr::cast_or_return(syntax).map(|x| Expr::TryExpr(x)), + TRY_BLOCK_EXPR => TryBlockExpr::cast_or_return(syntax).map(|x| Expr::TryBlockExpr(x)), + CAST_EXPR => CastExpr::cast_or_return(syntax).map(|x| Expr::CastExpr(x)), + REF_EXPR => RefExpr::cast_or_return(syntax).map(|x| Expr::RefExpr(x)), + PREFIX_EXPR => PrefixExpr::cast_or_return(syntax).map(|x| Expr::PrefixExpr(x)), + RANGE_EXPR => RangeExpr::cast_or_return(syntax).map(|x| Expr::RangeExpr(x)), + BIN_EXPR => BinExpr::cast_or_return(syntax).map(|x| Expr::BinExpr(x)), + LITERAL => Literal::cast_or_return(syntax).map(|x| Expr::Literal(x)), + MACRO_CALL => MacroCall::cast_or_return(syntax).map(|x| Expr::MacroCall(x)), + BOX_EXPR => BoxExpr::cast_or_return(syntax).map(|x| Expr::BoxExpr(x)), + _ => Err(syntax), + } } fn syntax(&self) -> &SyntaxNode { match self { - Expr::TupleExpr(it) => &it.syntax, - Expr::ArrayExpr(it) => &it.syntax, - Expr::ParenExpr(it) => &it.syntax, - Expr::PathExpr(it) => &it.syntax, - Expr::LambdaExpr(it) => &it.syntax, - Expr::IfExpr(it) => &it.syntax, - Expr::LoopExpr(it) => &it.syntax, - Expr::ForExpr(it) => &it.syntax, - Expr::WhileExpr(it) => &it.syntax, - Expr::ContinueExpr(it) => &it.syntax, - Expr::BreakExpr(it) => &it.syntax, - Expr::Label(it) => &it.syntax, - Expr::BlockExpr(it) => &it.syntax, - Expr::ReturnExpr(it) => &it.syntax, - Expr::MatchExpr(it) => &it.syntax, - Expr::RecordLit(it) => &it.syntax, - Expr::CallExpr(it) => &it.syntax, - Expr::IndexExpr(it) => &it.syntax, - Expr::MethodCallExpr(it) => &it.syntax, - Expr::FieldExpr(it) => &it.syntax, - Expr::AwaitExpr(it) => &it.syntax, - Expr::TryExpr(it) => &it.syntax, - Expr::TryBlockExpr(it) => &it.syntax, - Expr::CastExpr(it) => &it.syntax, - Expr::RefExpr(it) => &it.syntax, - Expr::PrefixExpr(it) => &it.syntax, - Expr::RangeExpr(it) => &it.syntax, - Expr::BinExpr(it) => &it.syntax, - Expr::Literal(it) => &it.syntax, - Expr::MacroCall(it) => &it.syntax, - Expr::BoxExpr(it) => &it.syntax, + Expr::TupleExpr(it) => it.syntax(), + Expr::ArrayExpr(it) => it.syntax(), + Expr::ParenExpr(it) => it.syntax(), + Expr::PathExpr(it) => it.syntax(), + Expr::LambdaExpr(it) => it.syntax(), + Expr::IfExpr(it) => it.syntax(), + Expr::LoopExpr(it) => it.syntax(), + Expr::ForExpr(it) => it.syntax(), + Expr::WhileExpr(it) => it.syntax(), + Expr::ContinueExpr(it) => it.syntax(), + Expr::BreakExpr(it) => it.syntax(), + Expr::Label(it) => it.syntax(), + Expr::BlockExpr(it) => it.syntax(), + Expr::ReturnExpr(it) => it.syntax(), + Expr::MatchExpr(it) => it.syntax(), + Expr::RecordLit(it) => it.syntax(), + Expr::CallExpr(it) => it.syntax(), + Expr::IndexExpr(it) => it.syntax(), + Expr::MethodCallExpr(it) => it.syntax(), + Expr::FieldExpr(it) => it.syntax(), + Expr::AwaitExpr(it) => it.syntax(), + Expr::TryExpr(it) => it.syntax(), + Expr::TryBlockExpr(it) => it.syntax(), + Expr::CastExpr(it) => it.syntax(), + Expr::RefExpr(it) => it.syntax(), + Expr::PrefixExpr(it) => it.syntax(), + Expr::RangeExpr(it) => it.syntax(), + Expr::BinExpr(it) => it.syntax(), + Expr::Literal(it) => it.syntax(), + Expr::MacroCall(it) => it.syntax(), + Expr::BoxExpr(it) => it.syntax(), + } + } + fn into_syntax(self) -> SyntaxNode { + match self { + Expr::TupleExpr(it) => it.into_syntax(), + Expr::ArrayExpr(it) => it.into_syntax(), + Expr::ParenExpr(it) => it.into_syntax(), + Expr::PathExpr(it) => it.into_syntax(), + Expr::LambdaExpr(it) => it.into_syntax(), + Expr::IfExpr(it) => it.into_syntax(), + Expr::LoopExpr(it) => it.into_syntax(), + Expr::ForExpr(it) => it.into_syntax(), + Expr::WhileExpr(it) => it.into_syntax(), + Expr::ContinueExpr(it) => it.into_syntax(), + Expr::BreakExpr(it) => it.into_syntax(), + Expr::Label(it) => it.into_syntax(), + Expr::BlockExpr(it) => it.into_syntax(), + Expr::ReturnExpr(it) => it.into_syntax(), + Expr::MatchExpr(it) => it.into_syntax(), + Expr::RecordLit(it) => it.into_syntax(), + Expr::CallExpr(it) => it.into_syntax(), + Expr::IndexExpr(it) => it.into_syntax(), + Expr::MethodCallExpr(it) => it.into_syntax(), + Expr::FieldExpr(it) => it.into_syntax(), + Expr::AwaitExpr(it) => it.into_syntax(), + Expr::TryExpr(it) => it.into_syntax(), + Expr::TryBlockExpr(it) => it.into_syntax(), + Expr::CastExpr(it) => it.into_syntax(), + Expr::RefExpr(it) => it.into_syntax(), + Expr::PrefixExpr(it) => it.into_syntax(), + Expr::RangeExpr(it) => it.into_syntax(), + Expr::BinExpr(it) => it.into_syntax(), + Expr::Literal(it) => it.into_syntax(), + Expr::MacroCall(it) => it.into_syntax(), + Expr::BoxExpr(it) => it.into_syntax(), + } + } +} +impl AstElement for Expr { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + ARRAY_EXPR | AWAIT_EXPR | BIN_EXPR | BLOCK_EXPR | BOX_EXPR | BREAK_EXPR | CALL_EXPR + | CAST_EXPR | CONTINUE_EXPR | FIELD_EXPR | FOR_EXPR | IF_EXPR | INDEX_EXPR | LABEL + | LAMBDA_EXPR | LITERAL | LOOP_EXPR | MACRO_CALL | MATCH_EXPR | METHOD_CALL_EXPR + | PAREN_EXPR | PATH_EXPR | PREFIX_EXPR | RANGE_EXPR | RECORD_LIT | REF_EXPR + | RETURN_EXPR | TRY_BLOCK_EXPR | TRY_EXPR | TUPLE_EXPR | WHILE_EXPR => true, + _ => false, + } + } + #[allow(unreachable_patterns)] + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + match syntax.kind() { + TUPLE_EXPR => TupleExpr::cast_or_return_element(syntax).map(|x| Expr::TupleExpr(x)), + ARRAY_EXPR => ArrayExpr::cast_or_return_element(syntax).map(|x| Expr::ArrayExpr(x)), + PAREN_EXPR => ParenExpr::cast_or_return_element(syntax).map(|x| Expr::ParenExpr(x)), + PATH_EXPR => PathExpr::cast_or_return_element(syntax).map(|x| Expr::PathExpr(x)), + LAMBDA_EXPR => LambdaExpr::cast_or_return_element(syntax).map(|x| Expr::LambdaExpr(x)), + IF_EXPR => IfExpr::cast_or_return_element(syntax).map(|x| Expr::IfExpr(x)), + LOOP_EXPR => LoopExpr::cast_or_return_element(syntax).map(|x| Expr::LoopExpr(x)), + FOR_EXPR => ForExpr::cast_or_return_element(syntax).map(|x| Expr::ForExpr(x)), + WHILE_EXPR => WhileExpr::cast_or_return_element(syntax).map(|x| Expr::WhileExpr(x)), + CONTINUE_EXPR => { + ContinueExpr::cast_or_return_element(syntax).map(|x| Expr::ContinueExpr(x)) + } + BREAK_EXPR => BreakExpr::cast_or_return_element(syntax).map(|x| Expr::BreakExpr(x)), + LABEL => Label::cast_or_return_element(syntax).map(|x| Expr::Label(x)), + BLOCK_EXPR => BlockExpr::cast_or_return_element(syntax).map(|x| Expr::BlockExpr(x)), + RETURN_EXPR => ReturnExpr::cast_or_return_element(syntax).map(|x| Expr::ReturnExpr(x)), + MATCH_EXPR => MatchExpr::cast_or_return_element(syntax).map(|x| Expr::MatchExpr(x)), + RECORD_LIT => RecordLit::cast_or_return_element(syntax).map(|x| Expr::RecordLit(x)), + CALL_EXPR => CallExpr::cast_or_return_element(syntax).map(|x| Expr::CallExpr(x)), + INDEX_EXPR => IndexExpr::cast_or_return_element(syntax).map(|x| Expr::IndexExpr(x)), + METHOD_CALL_EXPR => { + MethodCallExpr::cast_or_return_element(syntax).map(|x| Expr::MethodCallExpr(x)) + } + FIELD_EXPR => FieldExpr::cast_or_return_element(syntax).map(|x| Expr::FieldExpr(x)), + AWAIT_EXPR => AwaitExpr::cast_or_return_element(syntax).map(|x| Expr::AwaitExpr(x)), + TRY_EXPR => TryExpr::cast_or_return_element(syntax).map(|x| Expr::TryExpr(x)), + TRY_BLOCK_EXPR => { + TryBlockExpr::cast_or_return_element(syntax).map(|x| Expr::TryBlockExpr(x)) + } + CAST_EXPR => CastExpr::cast_or_return_element(syntax).map(|x| Expr::CastExpr(x)), + REF_EXPR => RefExpr::cast_or_return_element(syntax).map(|x| Expr::RefExpr(x)), + PREFIX_EXPR => PrefixExpr::cast_or_return_element(syntax).map(|x| Expr::PrefixExpr(x)), + RANGE_EXPR => RangeExpr::cast_or_return_element(syntax).map(|x| Expr::RangeExpr(x)), + BIN_EXPR => BinExpr::cast_or_return_element(syntax).map(|x| Expr::BinExpr(x)), + LITERAL => Literal::cast_or_return_element(syntax).map(|x| Expr::Literal(x)), + MACRO_CALL => MacroCall::cast_or_return_element(syntax).map(|x| Expr::MacroCall(x)), + BOX_EXPR => BoxExpr::cast_or_return_element(syntax).map(|x| Expr::BoxExpr(x)), + _ => Err(syntax), + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + match self { + Expr::TupleExpr(it) => it.syntax_element(), + Expr::ArrayExpr(it) => it.syntax_element(), + Expr::ParenExpr(it) => it.syntax_element(), + Expr::PathExpr(it) => it.syntax_element(), + Expr::LambdaExpr(it) => it.syntax_element(), + Expr::IfExpr(it) => it.syntax_element(), + Expr::LoopExpr(it) => it.syntax_element(), + Expr::ForExpr(it) => it.syntax_element(), + Expr::WhileExpr(it) => it.syntax_element(), + Expr::ContinueExpr(it) => it.syntax_element(), + Expr::BreakExpr(it) => it.syntax_element(), + Expr::Label(it) => it.syntax_element(), + Expr::BlockExpr(it) => it.syntax_element(), + Expr::ReturnExpr(it) => it.syntax_element(), + Expr::MatchExpr(it) => it.syntax_element(), + Expr::RecordLit(it) => it.syntax_element(), + Expr::CallExpr(it) => it.syntax_element(), + Expr::IndexExpr(it) => it.syntax_element(), + Expr::MethodCallExpr(it) => it.syntax_element(), + Expr::FieldExpr(it) => it.syntax_element(), + Expr::AwaitExpr(it) => it.syntax_element(), + Expr::TryExpr(it) => it.syntax_element(), + Expr::TryBlockExpr(it) => it.syntax_element(), + Expr::CastExpr(it) => it.syntax_element(), + Expr::RefExpr(it) => it.syntax_element(), + Expr::PrefixExpr(it) => it.syntax_element(), + Expr::RangeExpr(it) => it.syntax_element(), + Expr::BinExpr(it) => it.syntax_element(), + Expr::Literal(it) => it.syntax_element(), + Expr::MacroCall(it) => it.syntax_element(), + Expr::BoxExpr(it) => it.syntax_element(), + } + } + fn into_syntax_element(self) -> SyntaxElement { + match self { + Expr::TupleExpr(it) => it.into_syntax_element(), + Expr::ArrayExpr(it) => it.into_syntax_element(), + Expr::ParenExpr(it) => it.into_syntax_element(), + Expr::PathExpr(it) => it.into_syntax_element(), + Expr::LambdaExpr(it) => it.into_syntax_element(), + Expr::IfExpr(it) => it.into_syntax_element(), + Expr::LoopExpr(it) => it.into_syntax_element(), + Expr::ForExpr(it) => it.into_syntax_element(), + Expr::WhileExpr(it) => it.into_syntax_element(), + Expr::ContinueExpr(it) => it.into_syntax_element(), + Expr::BreakExpr(it) => it.into_syntax_element(), + Expr::Label(it) => it.into_syntax_element(), + Expr::BlockExpr(it) => it.into_syntax_element(), + Expr::ReturnExpr(it) => it.into_syntax_element(), + Expr::MatchExpr(it) => it.into_syntax_element(), + Expr::RecordLit(it) => it.into_syntax_element(), + Expr::CallExpr(it) => it.into_syntax_element(), + Expr::IndexExpr(it) => it.into_syntax_element(), + Expr::MethodCallExpr(it) => it.into_syntax_element(), + Expr::FieldExpr(it) => it.into_syntax_element(), + Expr::AwaitExpr(it) => it.into_syntax_element(), + Expr::TryExpr(it) => it.into_syntax_element(), + Expr::TryBlockExpr(it) => it.into_syntax_element(), + Expr::CastExpr(it) => it.into_syntax_element(), + Expr::RefExpr(it) => it.into_syntax_element(), + Expr::PrefixExpr(it) => it.into_syntax_element(), + Expr::RangeExpr(it) => it.into_syntax_element(), + Expr::BinExpr(it) => it.into_syntax_element(), + Expr::Literal(it) => it.into_syntax_element(), + Expr::MacroCall(it) => it.into_syntax_element(), + Expr::BoxExpr(it) => it.into_syntax_element(), } } } @@ -4673,54 +13524,161 @@ impl From for Pat { } impl std::fmt::Display for Pat { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) + match self { + Pat::OrPat(it) => std::fmt::Display::fmt(it, f), + Pat::ParenPat(it) => std::fmt::Display::fmt(it, f), + Pat::RefPat(it) => std::fmt::Display::fmt(it, f), + Pat::BoxPat(it) => std::fmt::Display::fmt(it, f), + Pat::BindPat(it) => std::fmt::Display::fmt(it, f), + Pat::PlaceholderPat(it) => std::fmt::Display::fmt(it, f), + Pat::DotDotPat(it) => std::fmt::Display::fmt(it, f), + Pat::PathPat(it) => std::fmt::Display::fmt(it, f), + Pat::RecordPat(it) => std::fmt::Display::fmt(it, f), + Pat::TupleStructPat(it) => std::fmt::Display::fmt(it, f), + Pat::TuplePat(it) => std::fmt::Display::fmt(it, f), + Pat::SlicePat(it) => std::fmt::Display::fmt(it, f), + Pat::RangePat(it) => std::fmt::Display::fmt(it, f), + Pat::LiteralPat(it) => std::fmt::Display::fmt(it, f), + } } } impl AstNode for Pat { fn can_cast(kind: SyntaxKind) -> bool { match kind { - OR_PAT | PAREN_PAT | REF_PAT | BOX_PAT | BIND_PAT | PLACEHOLDER_PAT | DOT_DOT_PAT - | PATH_PAT | RECORD_PAT | TUPLE_STRUCT_PAT | TUPLE_PAT | SLICE_PAT | RANGE_PAT - | LITERAL_PAT => true, - _ => false, - } - } - fn cast(syntax: SyntaxNode) -> Option { - let res = match syntax.kind() { - OR_PAT => Pat::OrPat(OrPat { syntax }), - PAREN_PAT => Pat::ParenPat(ParenPat { syntax }), - REF_PAT => Pat::RefPat(RefPat { syntax }), - BOX_PAT => Pat::BoxPat(BoxPat { syntax }), - BIND_PAT => Pat::BindPat(BindPat { syntax }), - PLACEHOLDER_PAT => Pat::PlaceholderPat(PlaceholderPat { syntax }), - DOT_DOT_PAT => Pat::DotDotPat(DotDotPat { syntax }), - PATH_PAT => Pat::PathPat(PathPat { syntax }), - RECORD_PAT => Pat::RecordPat(RecordPat { syntax }), - TUPLE_STRUCT_PAT => Pat::TupleStructPat(TupleStructPat { syntax }), - TUPLE_PAT => Pat::TuplePat(TuplePat { syntax }), - SLICE_PAT => Pat::SlicePat(SlicePat { syntax }), - RANGE_PAT => Pat::RangePat(RangePat { syntax }), - LITERAL_PAT => Pat::LiteralPat(LiteralPat { syntax }), - _ => return None, - }; - Some(res) + BIND_PAT | BOX_PAT | DOT_DOT_PAT | LITERAL_PAT | OR_PAT | PAREN_PAT | PATH_PAT + | PLACEHOLDER_PAT | RANGE_PAT | RECORD_PAT | REF_PAT | SLICE_PAT | TUPLE_PAT + | TUPLE_STRUCT_PAT => true, + _ => false, + } + } + #[allow(unreachable_patterns)] + fn cast_or_return(syntax: SyntaxNode) -> Result { + match syntax.kind() { + OR_PAT => OrPat::cast_or_return(syntax).map(|x| Pat::OrPat(x)), + PAREN_PAT => ParenPat::cast_or_return(syntax).map(|x| Pat::ParenPat(x)), + REF_PAT => RefPat::cast_or_return(syntax).map(|x| Pat::RefPat(x)), + BOX_PAT => BoxPat::cast_or_return(syntax).map(|x| Pat::BoxPat(x)), + BIND_PAT => BindPat::cast_or_return(syntax).map(|x| Pat::BindPat(x)), + PLACEHOLDER_PAT => { + PlaceholderPat::cast_or_return(syntax).map(|x| Pat::PlaceholderPat(x)) + } + DOT_DOT_PAT => DotDotPat::cast_or_return(syntax).map(|x| Pat::DotDotPat(x)), + PATH_PAT => PathPat::cast_or_return(syntax).map(|x| Pat::PathPat(x)), + RECORD_PAT => RecordPat::cast_or_return(syntax).map(|x| Pat::RecordPat(x)), + TUPLE_STRUCT_PAT => { + TupleStructPat::cast_or_return(syntax).map(|x| Pat::TupleStructPat(x)) + } + TUPLE_PAT => TuplePat::cast_or_return(syntax).map(|x| Pat::TuplePat(x)), + SLICE_PAT => SlicePat::cast_or_return(syntax).map(|x| Pat::SlicePat(x)), + RANGE_PAT => RangePat::cast_or_return(syntax).map(|x| Pat::RangePat(x)), + LITERAL_PAT => LiteralPat::cast_or_return(syntax).map(|x| Pat::LiteralPat(x)), + _ => Err(syntax), + } } fn syntax(&self) -> &SyntaxNode { match self { - Pat::OrPat(it) => &it.syntax, - Pat::ParenPat(it) => &it.syntax, - Pat::RefPat(it) => &it.syntax, - Pat::BoxPat(it) => &it.syntax, - Pat::BindPat(it) => &it.syntax, - Pat::PlaceholderPat(it) => &it.syntax, - Pat::DotDotPat(it) => &it.syntax, - Pat::PathPat(it) => &it.syntax, - Pat::RecordPat(it) => &it.syntax, - Pat::TupleStructPat(it) => &it.syntax, - Pat::TuplePat(it) => &it.syntax, - Pat::SlicePat(it) => &it.syntax, - Pat::RangePat(it) => &it.syntax, - Pat::LiteralPat(it) => &it.syntax, + Pat::OrPat(it) => it.syntax(), + Pat::ParenPat(it) => it.syntax(), + Pat::RefPat(it) => it.syntax(), + Pat::BoxPat(it) => it.syntax(), + Pat::BindPat(it) => it.syntax(), + Pat::PlaceholderPat(it) => it.syntax(), + Pat::DotDotPat(it) => it.syntax(), + Pat::PathPat(it) => it.syntax(), + Pat::RecordPat(it) => it.syntax(), + Pat::TupleStructPat(it) => it.syntax(), + Pat::TuplePat(it) => it.syntax(), + Pat::SlicePat(it) => it.syntax(), + Pat::RangePat(it) => it.syntax(), + Pat::LiteralPat(it) => it.syntax(), + } + } + fn into_syntax(self) -> SyntaxNode { + match self { + Pat::OrPat(it) => it.into_syntax(), + Pat::ParenPat(it) => it.into_syntax(), + Pat::RefPat(it) => it.into_syntax(), + Pat::BoxPat(it) => it.into_syntax(), + Pat::BindPat(it) => it.into_syntax(), + Pat::PlaceholderPat(it) => it.into_syntax(), + Pat::DotDotPat(it) => it.into_syntax(), + Pat::PathPat(it) => it.into_syntax(), + Pat::RecordPat(it) => it.into_syntax(), + Pat::TupleStructPat(it) => it.into_syntax(), + Pat::TuplePat(it) => it.into_syntax(), + Pat::SlicePat(it) => it.into_syntax(), + Pat::RangePat(it) => it.into_syntax(), + Pat::LiteralPat(it) => it.into_syntax(), + } + } +} +impl AstElement for Pat { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + BIND_PAT | BOX_PAT | DOT_DOT_PAT | LITERAL_PAT | OR_PAT | PAREN_PAT | PATH_PAT + | PLACEHOLDER_PAT | RANGE_PAT | RECORD_PAT | REF_PAT | SLICE_PAT | TUPLE_PAT + | TUPLE_STRUCT_PAT => true, + _ => false, + } + } + #[allow(unreachable_patterns)] + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + match syntax.kind() { + OR_PAT => OrPat::cast_or_return_element(syntax).map(|x| Pat::OrPat(x)), + PAREN_PAT => ParenPat::cast_or_return_element(syntax).map(|x| Pat::ParenPat(x)), + REF_PAT => RefPat::cast_or_return_element(syntax).map(|x| Pat::RefPat(x)), + BOX_PAT => BoxPat::cast_or_return_element(syntax).map(|x| Pat::BoxPat(x)), + BIND_PAT => BindPat::cast_or_return_element(syntax).map(|x| Pat::BindPat(x)), + PLACEHOLDER_PAT => { + PlaceholderPat::cast_or_return_element(syntax).map(|x| Pat::PlaceholderPat(x)) + } + DOT_DOT_PAT => DotDotPat::cast_or_return_element(syntax).map(|x| Pat::DotDotPat(x)), + PATH_PAT => PathPat::cast_or_return_element(syntax).map(|x| Pat::PathPat(x)), + RECORD_PAT => RecordPat::cast_or_return_element(syntax).map(|x| Pat::RecordPat(x)), + TUPLE_STRUCT_PAT => { + TupleStructPat::cast_or_return_element(syntax).map(|x| Pat::TupleStructPat(x)) + } + TUPLE_PAT => TuplePat::cast_or_return_element(syntax).map(|x| Pat::TuplePat(x)), + SLICE_PAT => SlicePat::cast_or_return_element(syntax).map(|x| Pat::SlicePat(x)), + RANGE_PAT => RangePat::cast_or_return_element(syntax).map(|x| Pat::RangePat(x)), + LITERAL_PAT => LiteralPat::cast_or_return_element(syntax).map(|x| Pat::LiteralPat(x)), + _ => Err(syntax), + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + match self { + Pat::OrPat(it) => it.syntax_element(), + Pat::ParenPat(it) => it.syntax_element(), + Pat::RefPat(it) => it.syntax_element(), + Pat::BoxPat(it) => it.syntax_element(), + Pat::BindPat(it) => it.syntax_element(), + Pat::PlaceholderPat(it) => it.syntax_element(), + Pat::DotDotPat(it) => it.syntax_element(), + Pat::PathPat(it) => it.syntax_element(), + Pat::RecordPat(it) => it.syntax_element(), + Pat::TupleStructPat(it) => it.syntax_element(), + Pat::TuplePat(it) => it.syntax_element(), + Pat::SlicePat(it) => it.syntax_element(), + Pat::RangePat(it) => it.syntax_element(), + Pat::LiteralPat(it) => it.syntax_element(), + } + } + fn into_syntax_element(self) -> SyntaxElement { + match self { + Pat::OrPat(it) => it.into_syntax_element(), + Pat::ParenPat(it) => it.into_syntax_element(), + Pat::RefPat(it) => it.into_syntax_element(), + Pat::BoxPat(it) => it.into_syntax_element(), + Pat::BindPat(it) => it.into_syntax_element(), + Pat::PlaceholderPat(it) => it.into_syntax_element(), + Pat::DotDotPat(it) => it.into_syntax_element(), + Pat::PathPat(it) => it.into_syntax_element(), + Pat::RecordPat(it) => it.into_syntax_element(), + Pat::TupleStructPat(it) => it.into_syntax_element(), + Pat::TuplePat(it) => it.into_syntax_element(), + Pat::SlicePat(it) => it.into_syntax_element(), + Pat::RangePat(it) => it.into_syntax_element(), + Pat::LiteralPat(it) => it.into_syntax_element(), } } } @@ -4741,7 +13699,10 @@ impl From for AttrInput { } impl std::fmt::Display for AttrInput { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) + match self { + AttrInput::Literal(it) => std::fmt::Display::fmt(it, f), + AttrInput::TokenTree(it) => std::fmt::Display::fmt(it, f), + } } } impl AstNode for AttrInput { @@ -4751,18 +13712,54 @@ impl AstNode for AttrInput { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - let res = match syntax.kind() { - LITERAL => AttrInput::Literal(Literal { syntax }), - TOKEN_TREE => AttrInput::TokenTree(TokenTree { syntax }), - _ => return None, - }; - Some(res) + #[allow(unreachable_patterns)] + fn cast_or_return(syntax: SyntaxNode) -> Result { + match syntax.kind() { + LITERAL => Literal::cast_or_return(syntax).map(|x| AttrInput::Literal(x)), + TOKEN_TREE => TokenTree::cast_or_return(syntax).map(|x| AttrInput::TokenTree(x)), + _ => Err(syntax), + } } fn syntax(&self) -> &SyntaxNode { match self { - AttrInput::Literal(it) => &it.syntax, - AttrInput::TokenTree(it) => &it.syntax, + AttrInput::Literal(it) => it.syntax(), + AttrInput::TokenTree(it) => it.syntax(), + } + } + fn into_syntax(self) -> SyntaxNode { + match self { + AttrInput::Literal(it) => it.into_syntax(), + AttrInput::TokenTree(it) => it.into_syntax(), + } + } +} +impl AstElement for AttrInput { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + LITERAL | TOKEN_TREE => true, + _ => false, + } + } + #[allow(unreachable_patterns)] + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + match syntax.kind() { + LITERAL => Literal::cast_or_return_element(syntax).map(|x| AttrInput::Literal(x)), + TOKEN_TREE => { + TokenTree::cast_or_return_element(syntax).map(|x| AttrInput::TokenTree(x)) + } + _ => Err(syntax), + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + match self { + AttrInput::Literal(it) => it.syntax_element(), + AttrInput::TokenTree(it) => it.syntax_element(), + } + } + fn into_syntax_element(self) -> SyntaxElement { + match self { + AttrInput::Literal(it) => it.into_syntax_element(), + AttrInput::TokenTree(it) => it.into_syntax_element(), } } } @@ -4783,7 +13780,10 @@ impl From for Stmt { } impl std::fmt::Display for Stmt { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) + match self { + Stmt::ExprStmt(it) => std::fmt::Display::fmt(it, f), + Stmt::LetStmt(it) => std::fmt::Display::fmt(it, f), + } } } impl AstNode for Stmt { @@ -4793,18 +13793,52 @@ impl AstNode for Stmt { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - let res = match syntax.kind() { - EXPR_STMT => Stmt::ExprStmt(ExprStmt { syntax }), - LET_STMT => Stmt::LetStmt(LetStmt { syntax }), - _ => return None, - }; - Some(res) + #[allow(unreachable_patterns)] + fn cast_or_return(syntax: SyntaxNode) -> Result { + match syntax.kind() { + EXPR_STMT => ExprStmt::cast_or_return(syntax).map(|x| Stmt::ExprStmt(x)), + LET_STMT => LetStmt::cast_or_return(syntax).map(|x| Stmt::LetStmt(x)), + _ => Err(syntax), + } } fn syntax(&self) -> &SyntaxNode { match self { - Stmt::ExprStmt(it) => &it.syntax, - Stmt::LetStmt(it) => &it.syntax, + Stmt::ExprStmt(it) => it.syntax(), + Stmt::LetStmt(it) => it.syntax(), + } + } + fn into_syntax(self) -> SyntaxNode { + match self { + Stmt::ExprStmt(it) => it.into_syntax(), + Stmt::LetStmt(it) => it.into_syntax(), + } + } +} +impl AstElement for Stmt { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + EXPR_STMT | LET_STMT => true, + _ => false, + } + } + #[allow(unreachable_patterns)] + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + match syntax.kind() { + EXPR_STMT => ExprStmt::cast_or_return_element(syntax).map(|x| Stmt::ExprStmt(x)), + LET_STMT => LetStmt::cast_or_return_element(syntax).map(|x| Stmt::LetStmt(x)), + _ => Err(syntax), + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + match self { + Stmt::ExprStmt(it) => it.syntax_element(), + Stmt::LetStmt(it) => it.syntax_element(), + } + } + fn into_syntax_element(self) -> SyntaxElement { + match self { + Stmt::ExprStmt(it) => it.into_syntax_element(), + Stmt::LetStmt(it) => it.into_syntax_element(), } } } diff --git a/crates/ra_syntax/src/ast/tokens.rs b/crates/ra_syntax/src/ast/tokens.rs index 1a51b8d3b917..e8320b57ed45 100644 --- a/crates/ra_syntax/src/ast/tokens.rs +++ b/crates/ra_syntax/src/ast/tokens.rs @@ -1,26 +1,10 @@ //! There are many AstNodes, but only a few tokens, so we hand-write them here. use crate::{ - ast::AstToken, - SyntaxKind::{COMMENT, RAW_STRING, STRING, WHITESPACE}, - SyntaxToken, TextRange, TextUnit, + ast::{AstToken, Comment, RawString, String, Whitespace}, + TextRange, TextUnit, }; -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Comment(SyntaxToken); - -impl AstToken for Comment { - fn cast(token: SyntaxToken) -> Option { - match token.kind() { - COMMENT => Some(Comment(token)), - _ => None, - } - } - fn syntax(&self) -> &SyntaxToken { - &self.0 - } -} - impl Comment { pub fn kind(&self) -> CommentKind { kind_by_prefix(self.text()) @@ -89,20 +73,6 @@ fn prefix_by_kind(kind: CommentKind) -> &'static str { unreachable!() } -pub struct Whitespace(SyntaxToken); - -impl AstToken for Whitespace { - fn cast(token: SyntaxToken) -> Option { - match token.kind() { - WHITESPACE => Some(Whitespace(token)), - _ => None, - } - } - fn syntax(&self) -> &SyntaxToken { - &self.0 - } -} - impl Whitespace { pub fn spans_multiple_lines(&self) -> bool { let text = self.text(); @@ -168,20 +138,6 @@ pub trait HasStringValue: HasQuotes { fn value(&self) -> Option; } -pub struct String(SyntaxToken); - -impl AstToken for String { - fn cast(token: SyntaxToken) -> Option { - match token.kind() { - STRING => Some(String(token)), - _ => None, - } - } - fn syntax(&self) -> &SyntaxToken { - &self.0 - } -} - impl HasStringValue for String { fn value(&self) -> Option { let text = self.text().as_str(); @@ -201,20 +157,6 @@ impl HasStringValue for String { } } -pub struct RawString(SyntaxToken); - -impl AstToken for RawString { - fn cast(token: SyntaxToken) -> Option { - match token.kind() { - RAW_STRING => Some(RawString(token)), - _ => None, - } - } - fn syntax(&self) -> &SyntaxToken { - &self.0 - } -} - impl HasStringValue for RawString { fn value(&self) -> Option { let text = self.text().as_str(); diff --git a/xtask/src/codegen/gen_syntax.rs b/xtask/src/codegen/gen_syntax.rs index 32afd47bc324..c730c75eed03 100644 --- a/xtask/src/codegen/gen_syntax.rs +++ b/xtask/src/codegen/gen_syntax.rs @@ -5,6 +5,8 @@ use proc_macro2::{Punct, Spacing}; use quote::{format_ident, quote}; +use std::borrow::Cow; +use std::collections::{BTreeSet, HashMap, HashSet}; use crate::{ ast_src::{AstSrc, FieldSrc, KindsSrc, AST_SRC, KINDS_SRC}, @@ -18,13 +20,125 @@ pub fn generate_syntax(mode: Mode) -> Result<()> { update(syntax_kinds_file.as_path(), &syntax_kinds, mode)?; let ast_file = project_root().join(codegen::AST); - let ast = generate_ast(AST_SRC)?; + let ast = generate_ast(KINDS_SRC, AST_SRC)?; update(ast_file.as_path(), &ast, mode)?; Ok(()) } -fn generate_ast(grammar: AstSrc<'_>) -> Result { +#[derive(Debug, Default, Clone)] +struct ElementKinds { + kinds: BTreeSet, + has_nodes: bool, + has_tokens: bool, +} + +fn generate_ast(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result { + let all_token_kinds: Vec<_> = kinds + .punct + .into_iter() + .map(|(_, kind)| kind) + .copied() + .map(|x| x.into()) + .chain( + kinds + .keywords + .into_iter() + .chain(kinds.contextual_keywords.into_iter()) + .map(|name| Cow::Owned(format!("{}_KW", to_upper_snake_case(&name)))), + ) + .chain(kinds.literals.into_iter().copied().map(|x| x.into())) + .chain(kinds.tokens.into_iter().copied().map(|x| x.into())) + .collect(); + + let mut element_kinds_map = HashMap::new(); + for kind in &all_token_kinds { + let kind = &**kind; + let name = to_pascal_case(kind); + element_kinds_map.insert( + name, + ElementKinds { + kinds: Some(format_ident!("{}", kind)).into_iter().collect(), + has_nodes: false, + has_tokens: true, + }, + ); + } + + for kind in kinds.nodes { + let name = to_pascal_case(kind); + element_kinds_map.insert( + name, + ElementKinds { + kinds: Some(format_ident!("{}", *kind)).into_iter().collect(), + has_nodes: true, + has_tokens: false, + }, + ); + } + + for en in grammar.enums { + let mut element_kinds: ElementKinds = Default::default(); + for variant in en.variants { + if let Some(variant_element_kinds) = element_kinds_map.get(*variant) { + element_kinds.kinds.extend(variant_element_kinds.kinds.iter().cloned()); + element_kinds.has_tokens |= variant_element_kinds.has_tokens; + element_kinds.has_nodes |= variant_element_kinds.has_nodes; + } else { + panic!("Enum variant has type that does not exist or was not declared before the enum: {}", *variant); + } + } + element_kinds_map.insert(en.name.to_string(), element_kinds); + } + + let tokens = all_token_kinds.iter().map(|kind_str| { + let kind_str = &**kind_str; + let kind = format_ident!("{}", kind_str); + let name = format_ident!("{}", to_pascal_case(kind_str)); + quote! { + #[derive(Debug, Clone, PartialEq, Eq, Hash)] + pub struct #name(SyntaxToken); + + impl std::fmt::Display for #name { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } + } + + impl AstToken for #name { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + #kind => 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 #name { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + #kind => 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) + } + } + } + }); + let nodes = grammar.nodes.iter().map(|node| { let name = format_ident!("{}", node.name); let kind = format_ident!("{}", to_upper_snake_case(&name.to_string())); @@ -42,20 +156,28 @@ fn generate_ast(grammar: AstSrc<'_>) -> Result { FieldSrc::Optional(ty) | FieldSrc::Many(ty) => ty, FieldSrc::Shorthand => name, }; + let element_kinds = &element_kinds_map.get(*ty).unwrap_or_else(|| panic!("type not found: {}", *ty)); + let iter = if !element_kinds.has_tokens { + format_ident!("AstChildren") + } else if !element_kinds.has_nodes { + format_ident!("AstChildTokens") + } else { + format_ident!("AstChildElements") + }; let ty = format_ident!("{}", ty); match field { FieldSrc::Many(_) => { quote! { - pub fn #method_name(&self) -> AstChildren<#ty> { - AstChildren::new(&self.syntax) + pub fn #method_name(&self) -> #iter<#ty> { + #iter::new(&self.syntax) } } } FieldSrc::Optional(_) | FieldSrc::Shorthand => { quote! { pub fn #method_name(&self) -> Option<#ty> { - AstChildren::new(&self.syntax).next() + #iter::new(&self.syntax).next() } } } @@ -81,11 +203,31 @@ fn generate_ast(grammar: AstSrc<'_>) -> Result { _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None } + 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 #name { + fn can_cast_element(kind: SyntaxKind) -> bool { + match kind { + #kind => 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) + } + } + #(#traits)* impl #name { @@ -96,16 +238,71 @@ fn generate_ast(grammar: AstSrc<'_>) -> Result { let enums = grammar.enums.iter().map(|en| { let variants = en.variants.iter().map(|var| format_ident!("{}", var)).collect::>(); + let element_kinds = &element_kinds_map[&en.name.to_string()]; let name = format_ident!("{}", en.name); - let kinds = variants + let kinds = en.variants .iter() - .map(|name| format_ident!("{}", to_upper_snake_case(&name.to_string()))) + .map(|name| { + element_kinds_map[*name].kinds.iter().collect::>() + }) .collect::>(); let traits = en.traits.iter().map(|trait_name| { let trait_name = format_ident!("{}", trait_name); quote!(impl ast::#trait_name for #name {}) }); + let all_kinds = &element_kinds.kinds; + + let specific_ast_trait = if element_kinds.has_nodes != element_kinds.has_tokens { + let (ast_trait, syntax_type) = if element_kinds.has_tokens { + ( + quote!(AstToken), + quote!(SyntaxToken), + ) + } else { + ( + quote!(AstNode), + quote!(SyntaxNode), + ) + }; + + quote! { + impl #ast_trait for #name { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + #(#all_kinds)|* => true, + _ => false, + } + } + #[allow(unreachable_patterns)] + fn cast_or_return(syntax: #syntax_type) -> Result { + match syntax.kind() { + #( + #(#kinds)|* => #variants::cast_or_return(syntax).map(|x| #name::#variants(x)), + )* + _ => Err(syntax), + } + } + fn syntax(&self) -> &#syntax_type { + match self { + #( + #name::#variants(it) => it.syntax(), + )* + } + } + fn into_syntax(self) -> #syntax_type { + match self { + #( + #name::#variants(it) => it.into_syntax(), + )* + } + } + } + } + } else { + Default::default() + }; + quote! { #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum #name { @@ -122,44 +319,71 @@ fn generate_ast(grammar: AstSrc<'_>) -> Result { impl std::fmt::Display for #name { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) + match self { + #( + #name::#variants(it) => std::fmt::Display::fmt(it, f), + )* + } } } - impl AstNode for #name { - fn can_cast(kind: SyntaxKind) -> bool { + #specific_ast_trait + + impl AstElement for #name { + fn can_cast_element(kind: SyntaxKind) -> bool { match kind { - #(#kinds)|* => true, + #(#all_kinds)|* => true, _ => false, } } - fn cast(syntax: SyntaxNode) -> Option { - let res = match syntax.kind() { + #[allow(unreachable_patterns)] + fn cast_or_return_element(syntax: SyntaxElement) -> Result { + match syntax.kind() { + #( + #(#kinds)|* => #variants::cast_or_return_element(syntax).map(|x| #name::#variants(x)), + )* + _ => Err(syntax), + } + } + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + match self { #( - #kinds => #name::#variants(#variants { syntax }), + #name::#variants(it) => it.syntax_element(), )* - _ => return None, - }; - Some(res) + } } - fn syntax(&self) -> &SyntaxNode { + fn into_syntax_element(self) -> SyntaxElement { match self { #( - #name::#variants(it) => &it.syntax, + #name::#variants(it) => it.into_syntax_element(), )* } } } + #(#traits)* } }); + let defined_nodes: HashSet<_> = grammar.nodes.iter().map(|node| node.name).collect(); + + for node in kinds + .nodes + .iter() + .map(|kind| to_pascal_case(*kind)) + .filter(|name| !defined_nodes.contains(&**name)) + { + eprintln!("Warning: node {} not defined in ast source", node); + } + let ast = quote! { + #[allow(unused_imports)] use crate::{ - SyntaxNode, SyntaxKind::{self, *}, - ast::{self, AstNode, AstChildren}, + SyntaxNode, SyntaxToken, SyntaxElement, NodeOrToken, SyntaxKind::{self, *}, + ast::{self, AstNode, AstToken, AstElement, AstChildren, AstChildTokens, AstChildElements}, }; + #(#tokens)* #(#nodes)* #(#enums)* }; @@ -282,12 +506,12 @@ fn generate_syntax_kinds(grammar: KindsSrc<'_>) -> Result { fn to_upper_snake_case(s: &str) -> String { let mut buf = String::with_capacity(s.len()); - let mut prev_is_upper = None; + let mut prev = false; for c in s.chars() { - if c.is_ascii_uppercase() && prev_is_upper == Some(false) { + if c.is_ascii_uppercase() && prev { buf.push('_') } - prev_is_upper = Some(c.is_ascii_uppercase()); + prev = true; buf.push(c.to_ascii_uppercase()); } @@ -296,14 +520,30 @@ fn to_upper_snake_case(s: &str) -> String { fn to_lower_snake_case(s: &str) -> String { let mut buf = String::with_capacity(s.len()); - let mut prev_is_upper = None; + let mut prev = false; for c in s.chars() { - if c.is_ascii_uppercase() && prev_is_upper == Some(false) { + if c.is_ascii_uppercase() && prev { buf.push('_') } - prev_is_upper = Some(c.is_ascii_uppercase()); + prev = true; buf.push(c.to_ascii_lowercase()); } buf } + +fn to_pascal_case(s: &str) -> String { + let mut buf = String::with_capacity(s.len()); + let mut prev_is_underscore = true; + for c in s.chars() { + if c == '_' { + prev_is_underscore = true; + } else if prev_is_underscore { + buf.push(c.to_ascii_uppercase()); + prev_is_underscore = false; + } else { + buf.push(c.to_ascii_lowercase()); + } + } + buf +} From b46c77e22a723ec31db981bd5d9fa5271293c319 Mon Sep 17 00:00:00 2001 From: Luca Barbieri Date: Fri, 3 Apr 2020 21:12:09 +0200 Subject: [PATCH 3/7] Provide more complete AST accessors to support usage in rustc --- crates/ra_assists/src/handlers/add_impl.rs | 4 +- crates/ra_assists/src/handlers/add_new.rs | 5 +- .../src/handlers/introduce_variable.rs | 4 +- .../ra_assists/src/handlers/merge_imports.rs | 4 +- crates/ra_fmt/src/lib.rs | 6 +- crates/ra_hir_def/src/body/lower.rs | 10 +- crates/ra_hir_def/src/nameres/raw.rs | 4 + crates/ra_hir_def/src/path/lower.rs | 2 +- crates/ra_hir_def/src/path/lower/lower_use.rs | 2 +- crates/ra_hir_def/src/visibility.rs | 4 + crates/ra_hir_ty/src/tests.rs | 4 +- crates/ra_parser/src/syntax_kind/generated.rs | 6 +- crates/ra_syntax/src/ast.rs | 2 +- crates/ra_syntax/src/ast/edit.rs | 26 +- crates/ra_syntax/src/ast/expr_extensions.rs | 4 + crates/ra_syntax/src/ast/extensions.rs | 148 +- crates/ra_syntax/src/ast/generated.rs | 5008 +++++++++++++---- crates/ra_syntax/src/ast/traits.rs | 32 +- xtask/src/ast_src.rs | 383 +- 19 files changed, 4324 insertions(+), 1334 deletions(-) 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..7f3b1882c70c 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(_) 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/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/ast.rs b/crates/ra_syntax/src/ast.rs index 1ac0201b8135..5ee289e9ca98 100644 --- a/crates/ra_syntax/src/ast.rs +++ b/crates/ra_syntax/src/ast.rs @@ -369,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..efce8fe538e3 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 { + /// the "mut" in "mut self", not the one in "&mut self" + pub fn mut_kw(&self) -> Option { self.syntax() .children_with_tokens() .filter_map(|it| it.into_token()) - .find(|it| it.kind() == LIFETIME) + .take_while(|it| it.kind() != T![&]) + .find_map(ast::MutKw::cast) } -} -impl ast::TypeParam { - pub fn colon_token(&self) -> Option { + /// the "mut" in "&mut self", not the one in "mut self" + pub fn amp_mut_kw(&self) -> Option { self.syntax() .children_with_tokens() .filter_map(|it| it.into_token()) - .find(|it| it.kind() == T![:]) - } -} - -impl ast::WherePred { - pub fn lifetime_token(&self) -> Option { - self.syntax() - .children_with_tokens() - .filter_map(|it| it.into_token()) - .find(|it| it.kind() == LIFETIME) + .skip_while(|it| it.kind() != T![&]) + .find_map(ast::MutKw::cast) } } @@ -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,41 @@ impl ast::MacroCall { } } } + +impl ast::LifetimeParam { + pub fn lifetime_bounds(&self) -> impl Iterator { + self.syntax() + .children_with_tokens() + .filter_map(|it| it.into_token()) + .skip_while(|x| x.kind() != T![:]) + .filter_map(ast::Lifetime::cast) + } +} + +impl ast::RangePat { + pub fn start(&self) -> Option { + self.syntax() + .children_with_tokens() + .take_while(|it| !ast::RangeSeparator::can_cast_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) + } +} diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs index 9d7032ed7440..a945060b9540 100644 --- a/crates/ra_syntax/src/ast/generated.rs +++ b/crates/ra_syntax/src/ast/generated.rs @@ -4712,6 +4712,55 @@ impl AstElement for UnionKw { } } #[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 { @@ -5548,6 +5597,7 @@ impl AstElement for SourceFile { } impl ast::ModuleItemOwner for SourceFile {} impl ast::FnDefOwner for SourceFile {} +impl ast::AttrsOwner for SourceFile {} impl SourceFile { pub fn modules(&self) -> AstChildren { AstChildren::new(&self.syntax) @@ -5610,6 +5660,24 @@ impl ast::TypeParamsOwner for FnDef {} impl ast::DocCommentsOwner for FnDef {} impl ast::AttrsOwner for FnDef {} impl FnDef { + pub fn abi(&self) -> Option { + AstChildren::new(&self.syntax).next() + } + pub fn const_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn default_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn async_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn unsafe_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn fn_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn param_list(&self) -> Option { AstChildren::new(&self.syntax).next() } @@ -5619,6 +5687,9 @@ impl FnDef { pub fn body(&self) -> Option { AstChildren::new(&self.syntax).next() } + pub fn semi(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct RetType { @@ -5672,6 +5743,9 @@ impl AstElement for RetType { } } impl RetType { + pub fn thin_arrow(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn type_ref(&self) -> Option { AstChildren::new(&self.syntax).next() } @@ -5732,7 +5806,17 @@ impl ast::NameOwner for StructDef {} impl ast::TypeParamsOwner for StructDef {} impl ast::AttrsOwner for StructDef {} impl ast::DocCommentsOwner for StructDef {} -impl StructDef {} +impl StructDef { + pub fn struct_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn field_def_list(&self) -> Option { + AstChildren::new(&self.syntax).next() + } + pub fn semi(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } +} #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct UnionDef { pub(crate) syntax: SyntaxNode, @@ -5790,6 +5874,9 @@ impl ast::TypeParamsOwner for UnionDef {} impl ast::AttrsOwner for UnionDef {} impl ast::DocCommentsOwner for UnionDef {} impl UnionDef { + pub fn union_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn record_field_def_list(&self) -> Option { AstChildren::new(&self.syntax).next() } @@ -5846,9 +5933,15 @@ impl AstElement for RecordFieldDefList { } } impl RecordFieldDefList { + pub fn l_curly(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn fields(&self) -> AstChildren { AstChildren::new(&self.syntax) } + pub fn r_curly(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct RecordFieldDef { @@ -5959,9 +6052,15 @@ impl AstElement for TupleFieldDefList { } } impl TupleFieldDefList { + pub fn l_paren(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn fields(&self) -> AstChildren { AstChildren::new(&self.syntax) } + pub fn r_paren(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct TupleFieldDef { @@ -6078,6 +6177,9 @@ impl ast::TypeParamsOwner for EnumDef {} impl ast::AttrsOwner for EnumDef {} impl ast::DocCommentsOwner for EnumDef {} impl EnumDef { + pub fn enum_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn variant_list(&self) -> Option { AstChildren::new(&self.syntax).next() } @@ -6134,9 +6236,15 @@ impl AstElement for EnumVariantList { } } impl EnumVariantList { + pub fn l_curly(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn variants(&self) -> AstChildren { AstChildren::new(&self.syntax) } + pub fn r_curly(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct EnumVariant { @@ -6189,10 +6297,17 @@ impl AstElement for EnumVariant { 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 { + AstChildren::new(&self.syntax).next() + } + pub fn eq(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn expr(&self) -> Option { AstChildren::new(&self.syntax).next() } @@ -6255,6 +6370,15 @@ impl ast::DocCommentsOwner for TraitDef {} impl ast::TypeParamsOwner for TraitDef {} impl ast::TypeBoundsOwner for TraitDef {} impl TraitDef { + pub fn unsafe_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn auto_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn trait_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn item_list(&self) -> Option { AstChildren::new(&self.syntax).next() } @@ -6315,9 +6439,15 @@ impl ast::NameOwner for Module {} impl ast::AttrsOwner for Module {} impl ast::DocCommentsOwner for Module {} impl Module { + pub fn mod_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn item_list(&self) -> Option { AstChildren::new(&self.syntax).next() } + pub fn semi(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct ItemList { @@ -6373,9 +6503,15 @@ impl AstElement for ItemList { impl ast::FnDefOwner for ItemList {} impl ast::ModuleItemOwner for ItemList {} impl ItemList { + pub fn l_curly(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn impl_items(&self) -> AstChildren { AstChildren::new(&self.syntax) } + pub fn r_curly(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct ConstDef { @@ -6435,9 +6571,21 @@ impl ast::AttrsOwner for ConstDef {} impl ast::DocCommentsOwner for ConstDef {} impl ast::TypeAscriptionOwner for ConstDef {} impl ConstDef { + pub fn default_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn const_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn eq(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn body(&self) -> Option { AstChildren::new(&self.syntax).next() } + pub fn semi(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct StaticDef { @@ -6497,9 +6645,21 @@ impl ast::AttrsOwner for StaticDef {} impl ast::DocCommentsOwner for StaticDef {} impl ast::TypeAscriptionOwner for StaticDef {} impl StaticDef { + pub fn static_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn mut_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn eq(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn body(&self) -> Option { AstChildren::new(&self.syntax).next() } + pub fn semi(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct TypeAliasDef { @@ -6559,9 +6719,21 @@ impl ast::AttrsOwner for TypeAliasDef {} impl ast::DocCommentsOwner for TypeAliasDef {} impl ast::TypeBoundsOwner for TypeAliasDef {} impl TypeAliasDef { + pub fn default_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn type_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn eq(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn type_ref(&self) -> Option { AstChildren::new(&self.syntax).next() } + pub fn semi(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct ImplDef { @@ -6617,6 +6789,24 @@ impl AstElement for ImplDef { impl ast::TypeParamsOwner for ImplDef {} impl ast::AttrsOwner for ImplDef {} impl ImplDef { + pub fn default_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn const_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn unsafe_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn impl_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn excl(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn for_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn item_list(&self) -> Option { AstChildren::new(&self.syntax).next() } @@ -6673,9 +6863,15 @@ impl AstElement for ParenType { } } impl ParenType { + pub fn l_paren(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn type_ref(&self) -> Option { AstChildren::new(&self.syntax).next() } + pub fn r_paren(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct TupleType { @@ -6729,9 +6925,15 @@ impl AstElement for TupleType { } } impl TupleType { + pub fn l_paren(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn fields(&self) -> AstChildren { AstChildren::new(&self.syntax) } + pub fn r_paren(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct NeverType { @@ -6784,7 +6986,11 @@ impl AstElement for NeverType { NodeOrToken::Node(self.syntax) } } -impl NeverType {} +impl NeverType { + pub fn excl(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } +} #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct PathType { pub(crate) syntax: SyntaxNode, @@ -6893,6 +7099,12 @@ impl AstElement for PointerType { } } impl PointerType { + pub fn star(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn const_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn type_ref(&self) -> Option { AstChildren::new(&self.syntax).next() } @@ -6949,12 +7161,21 @@ impl AstElement for ArrayType { } } impl ArrayType { + pub fn l_brack(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn type_ref(&self) -> Option { AstChildren::new(&self.syntax).next() } + pub fn semi(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn expr(&self) -> Option { AstChildren::new(&self.syntax).next() } + pub fn r_brack(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct SliceType { @@ -7008,9 +7229,15 @@ impl AstElement for SliceType { } } impl SliceType { + pub fn l_brack(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn type_ref(&self) -> Option { AstChildren::new(&self.syntax).next() } + pub fn r_brack(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct ReferenceType { @@ -7064,6 +7291,15 @@ impl AstElement for ReferenceType { } } impl ReferenceType { + pub fn amp(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn lifetime(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn mut_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn type_ref(&self) -> Option { AstChildren::new(&self.syntax).next() } @@ -7119,7 +7355,11 @@ impl AstElement for PlaceholderType { NodeOrToken::Node(self.syntax) } } -impl PlaceholderType {} +impl PlaceholderType { + pub fn underscore(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } +} #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct FnPointerType { pub(crate) syntax: SyntaxNode, @@ -7172,6 +7412,15 @@ impl AstElement for FnPointerType { } } impl FnPointerType { + pub fn abi(&self) -> Option { + AstChildren::new(&self.syntax).next() + } + pub fn unsafe_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn fn_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn param_list(&self) -> Option { AstChildren::new(&self.syntax).next() } @@ -7231,6 +7480,12 @@ impl AstElement for ForType { } } impl ForType { + pub fn for_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn type_param_list(&self) -> Option { + AstChildren::new(&self.syntax).next() + } pub fn type_ref(&self) -> Option { AstChildren::new(&self.syntax).next() } @@ -7287,7 +7542,11 @@ impl AstElement for ImplTraitType { } } impl ast::TypeBoundsOwner for ImplTraitType {} -impl ImplTraitType {} +impl ImplTraitType { + pub fn impl_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } +} #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct DynTraitType { pub(crate) syntax: SyntaxNode, @@ -7340,7 +7599,11 @@ impl AstElement for DynTraitType { } } impl ast::TypeBoundsOwner for DynTraitType {} -impl DynTraitType {} +impl DynTraitType { + pub fn dyn_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } +} #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct TupleExpr { pub(crate) syntax: SyntaxNode, @@ -7392,10 +7655,17 @@ impl AstElement for TupleExpr { NodeOrToken::Node(self.syntax) } } +impl ast::AttrsOwner for TupleExpr {} impl TupleExpr { + pub fn l_paren(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn exprs(&self) -> AstChildren { AstChildren::new(&self.syntax) } + pub fn r_paren(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct ArrayExpr { @@ -7448,10 +7718,20 @@ impl AstElement for ArrayExpr { NodeOrToken::Node(self.syntax) } } +impl ast::AttrsOwner for ArrayExpr {} impl ArrayExpr { + pub fn l_brack(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn exprs(&self) -> AstChildren { AstChildren::new(&self.syntax) } + pub fn semi(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn r_brack(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct ParenExpr { @@ -7504,10 +7784,17 @@ impl AstElement for ParenExpr { NodeOrToken::Node(self.syntax) } } +impl ast::AttrsOwner for ParenExpr {} impl ParenExpr { + pub fn l_paren(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn expr(&self) -> Option { AstChildren::new(&self.syntax).next() } + pub fn r_paren(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct PathExpr { @@ -7616,7 +7903,17 @@ impl AstElement for LambdaExpr { NodeOrToken::Node(self.syntax) } } +impl ast::AttrsOwner for LambdaExpr {} impl LambdaExpr { + pub fn static_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn async_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn move_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn param_list(&self) -> Option { AstChildren::new(&self.syntax).next() } @@ -7678,7 +7975,11 @@ impl AstElement for IfExpr { NodeOrToken::Node(self.syntax) } } +impl ast::AttrsOwner for IfExpr {} impl IfExpr { + pub fn if_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn condition(&self) -> Option { AstChildren::new(&self.syntax).next() } @@ -7734,8 +8035,13 @@ impl AstElement for LoopExpr { NodeOrToken::Node(self.syntax) } } +impl ast::AttrsOwner for LoopExpr {} impl ast::LoopBodyOwner for LoopExpr {} -impl LoopExpr {} +impl LoopExpr { + pub fn loop_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } +} #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct TryBlockExpr { pub(crate) syntax: SyntaxNode, @@ -7787,7 +8093,11 @@ impl AstElement for TryBlockExpr { NodeOrToken::Node(self.syntax) } } +impl ast::AttrsOwner for TryBlockExpr {} impl TryBlockExpr { + pub fn try_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn body(&self) -> Option { AstChildren::new(&self.syntax).next() } @@ -7843,11 +8153,18 @@ impl AstElement for ForExpr { NodeOrToken::Node(self.syntax) } } +impl ast::AttrsOwner for ForExpr {} impl ast::LoopBodyOwner for ForExpr {} impl ForExpr { + pub fn for_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn pat(&self) -> Option { AstChildren::new(&self.syntax).next() } + pub fn in_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn iterable(&self) -> Option { AstChildren::new(&self.syntax).next() } @@ -7903,8 +8220,12 @@ impl AstElement for WhileExpr { NodeOrToken::Node(self.syntax) } } +impl ast::AttrsOwner for WhileExpr {} impl ast::LoopBodyOwner for WhileExpr {} impl WhileExpr { + pub fn while_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn condition(&self) -> Option { AstChildren::new(&self.syntax).next() } @@ -7960,7 +8281,15 @@ impl AstElement for ContinueExpr { NodeOrToken::Node(self.syntax) } } -impl ContinueExpr {} +impl ast::AttrsOwner for ContinueExpr {} +impl ContinueExpr { + pub fn continue_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn lifetime(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } +} #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct BreakExpr { pub(crate) syntax: SyntaxNode, @@ -8012,7 +8341,14 @@ impl AstElement for BreakExpr { NodeOrToken::Node(self.syntax) } } +impl ast::AttrsOwner for BreakExpr {} impl BreakExpr { + pub fn break_kw(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } + pub fn lifetime(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } pub fn expr(&self) -> Option { AstChildren::new(&self.syntax).next() } @@ -8068,7 +8404,11 @@ impl AstElement for Label { NodeOrToken::Node(self.syntax) } } -impl Label {} +impl Label { + pub fn lifetime(&self) -> Option { + AstChildTokens::new(&self.syntax).next() + } +} #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct BlockExpr { pub(crate) syntax: SyntaxNode, @@ -8120,7 +8460,14 @@ impl AstElement for BlockExpr { NodeOrToken::Node(self.syntax) } } +impl ast::AttrsOwner for BlockExpr {} impl BlockExpr { + pub fn label(&self) -> Option