From 8f01e62bb962fbe282344125f6ace54326efcaa3 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Thu, 9 Apr 2020 10:47:05 +0200 Subject: [PATCH] Scale back the traits --- crates/ra_syntax/src/ast.rs | 108 +- crates/ra_syntax/src/ast/generated.rs | 3030 ++++++++++++++++++++++++- xtask/src/codegen/gen_syntax.rs | 168 +- 3 files changed, 3061 insertions(+), 245 deletions(-) diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs index 1ac0201b81..ab0f44dd2e 100644 --- a/crates/ra_syntax/src/ast.rs +++ b/crates/ra_syntax/src/ast.rs @@ -11,10 +11,7 @@ pub mod make; use std::marker::PhantomData; use crate::{ - syntax_node::{ - NodeOrToken, SyntaxElement, SyntaxElementChildren, SyntaxNode, SyntaxNodeChildren, - SyntaxToken, - }, + syntax_node::{SyntaxNode, SyntaxNodeChildren, SyntaxToken}, SmolStr, SyntaxKind, }; @@ -33,24 +30,16 @@ 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: AstElement { +pub trait AstNode { fn can_cast(kind: SyntaxKind) -> bool where Self: Sized; - fn cast_or_return(syntax: SyntaxNode) -> Result - where - Self: Sized; - fn cast(syntax: SyntaxNode) -> Option where - Self: Sized, - { - ::cast_or_return(syntax).ok() - } + Self: Sized; fn syntax(&self) -> &SyntaxNode; - fn into_syntax(self) -> SyntaxNode; } #[test] @@ -59,51 +48,22 @@ fn assert_ast_is_object_safe() { } /// Like `AstNode`, but wraps tokens rather than interior nodes. -pub trait AstToken: AstElement { +pub trait AstToken { 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() - } + Self: Sized; 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 { @@ -132,64 +92,6 @@ 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 0c339b9879..385fddc89e 100644 --- a/crates/ra_syntax/src/ast/generated.rs +++ b/crates/ra_syntax/src/ast/generated.rs @@ -1,11 +1,3037 @@ //! Generated file, do not edit by hand, see `xtask/src/codegen` +#[allow(unused_imports)] use crate::{ - ast::{self, AstChildren, AstNode}, + ast::{self, AstChildren, AstNode, AstToken}, + NodeOrToken, SyntaxElement, SyntaxKind::{self, *}, - SyntaxNode, + SyntaxNode, SyntaxToken, }; #[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Semi { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Semi { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Semi { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + SEMI => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Comma { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Comma { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Comma { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + COMMA => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct LParen { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for LParen { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for LParen { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + L_PAREN => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RParen { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for RParen { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for RParen { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + R_PAREN => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct LCurly { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for LCurly { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for LCurly { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + L_CURLY => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RCurly { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for RCurly { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for RCurly { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + R_CURLY => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct LBrack { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for LBrack { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for LBrack { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + L_BRACK => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RBrack { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for RBrack { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for RBrack { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + R_BRACK => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct LAngle { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for LAngle { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for LAngle { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + L_ANGLE => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RAngle { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for RAngle { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for RAngle { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + R_ANGLE => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct At { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for At { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for At { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + AT => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Pound { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Pound { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Pound { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + POUND => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Tilde { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Tilde { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Tilde { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + TILDE => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Question { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Question { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Question { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + QUESTION => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Dollar { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Dollar { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Dollar { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + DOLLAR => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Amp { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Amp { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Amp { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + AMP => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Pipe { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Pipe { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Pipe { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + PIPE => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Plus { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Plus { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Plus { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + PLUS => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Star { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Star { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Star { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + STAR => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Slash { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Slash { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Slash { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + SLASH => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Caret { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Caret { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Caret { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + CARET => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Percent { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Percent { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Percent { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + PERCENT => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Underscore { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Underscore { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Underscore { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + UNDERSCORE => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Dot { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Dot { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Dot { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + DOT => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Dotdot { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Dotdot { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Dotdot { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + DOTDOT => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Dotdotdot { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Dotdotdot { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Dotdotdot { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + DOTDOTDOT => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Dotdoteq { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Dotdoteq { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Dotdoteq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + DOTDOTEQ => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Colon { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Colon { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Colon { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + COLON => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Coloncolon { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Coloncolon { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Coloncolon { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + COLONCOLON => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Eq { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Eq { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Eq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + EQ => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Eqeq { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Eqeq { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Eqeq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + EQEQ => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct FatArrow { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for FatArrow { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for FatArrow { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + FAT_ARROW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Excl { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Excl { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Excl { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + EXCL => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Neq { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Neq { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Neq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + NEQ => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Minus { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Minus { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Minus { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + MINUS => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ThinArrow { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for ThinArrow { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for ThinArrow { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + THIN_ARROW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Lteq { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Lteq { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Lteq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + LTEQ => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Gteq { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Gteq { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Gteq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + GTEQ => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Pluseq { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Pluseq { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Pluseq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + PLUSEQ => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Minuseq { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Minuseq { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Minuseq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + MINUSEQ => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Pipeeq { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Pipeeq { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Pipeeq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + PIPEEQ => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Ampeq { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Ampeq { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Ampeq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + AMPEQ => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Careteq { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Careteq { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Careteq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + CARETEQ => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Slasheq { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Slasheq { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Slasheq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + SLASHEQ => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Stareq { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Stareq { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Stareq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + STAREQ => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Percenteq { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Percenteq { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Percenteq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + PERCENTEQ => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Ampamp { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Ampamp { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Ampamp { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + AMPAMP => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Pipepipe { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Pipepipe { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Pipepipe { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + PIPEPIPE => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Shl { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Shl { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Shl { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + SHL => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Shr { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Shr { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Shr { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + SHR => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Shleq { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Shleq { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Shleq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + SHLEQ => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Shreq { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Shreq { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Shreq { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + SHREQ => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AsKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for AsKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for AsKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + AS_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AsyncKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for AsyncKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for AsyncKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + ASYNC_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AwaitKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for AwaitKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for AwaitKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + AWAIT_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct BoxKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for BoxKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for BoxKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + BOX_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct BreakKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for BreakKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for BreakKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + BREAK_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ConstKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for ConstKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for ConstKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + CONST_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ContinueKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for ContinueKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for ContinueKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + CONTINUE_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct CrateKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for CrateKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for CrateKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + CRATE_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DynKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for DynKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for DynKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + DYN_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ElseKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for ElseKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for ElseKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + ELSE_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct EnumKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for EnumKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for EnumKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + ENUM_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ExternKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for ExternKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for ExternKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + EXTERN_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct FalseKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for FalseKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for FalseKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + FALSE_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct FnKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for FnKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for FnKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + FN_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ForKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for ForKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for ForKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + FOR_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct IfKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for IfKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for IfKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + IF_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ImplKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for ImplKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for ImplKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + IMPL_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct InKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for InKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for InKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + IN_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct LetKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for LetKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for LetKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + LET_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct LoopKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for LoopKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for LoopKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + LOOP_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct MacroKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for MacroKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for MacroKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + MACRO_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct MatchKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for MatchKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for MatchKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + MATCH_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ModKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for ModKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for ModKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + MOD_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct MoveKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for MoveKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for MoveKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + MOVE_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct MutKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for MutKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for MutKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + MUT_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct PubKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for PubKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for PubKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + PUB_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RefKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for RefKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for RefKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + REF_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ReturnKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for ReturnKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for ReturnKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + RETURN_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SelfKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for SelfKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for SelfKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + SELF_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct StaticKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for StaticKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for StaticKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + STATIC_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct StructKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for StructKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for StructKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + STRUCT_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct SuperKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for SuperKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for SuperKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + SUPER_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TraitKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for TraitKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for TraitKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + TRAIT_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TrueKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for TrueKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for TrueKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + TRUE_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TryKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for TryKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for TryKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + TRY_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct TypeKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for TypeKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for TypeKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + TYPE_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct UnsafeKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for UnsafeKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for UnsafeKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + UNSAFE_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct UseKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for UseKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for UseKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + USE_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct WhereKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for WhereKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for WhereKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + WHERE_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct WhileKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for WhileKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for WhileKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + WHILE_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct AutoKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for AutoKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for AutoKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + AUTO_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct DefaultKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for DefaultKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for DefaultKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + DEFAULT_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ExistentialKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for ExistentialKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for ExistentialKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + EXISTENTIAL_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct UnionKw { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for UnionKw { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for UnionKw { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + UNION_KW => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct IntNumber { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for IntNumber { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for IntNumber { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + INT_NUMBER => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct FloatNumber { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for FloatNumber { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for FloatNumber { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + FLOAT_NUMBER => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Char { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Char { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Char { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + CHAR => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Byte { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Byte { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Byte { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + BYTE => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct String { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for String { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for String { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + STRING => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RawString { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for RawString { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for RawString { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + RAW_STRING => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct ByteString { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for ByteString { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for ByteString { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + BYTE_STRING => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RawByteString { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for RawByteString { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for RawByteString { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + RAW_BYTE_STRING => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Error { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Error { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Error { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + ERROR => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Ident { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Ident { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Ident { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + IDENT => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Whitespace { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Whitespace { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Whitespace { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + WHITESPACE => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Lifetime { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Lifetime { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Lifetime { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + LIFETIME => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Comment { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Comment { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Comment { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + COMMENT => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Shebang { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for Shebang { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for Shebang { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + SHEBANG => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct LDollar { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for LDollar { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for LDollar { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + L_DOLLAR => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct RDollar { + pub(crate) syntax: SyntaxToken, +} +impl std::fmt::Display for RDollar { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(&self.syntax, f) + } +} +impl AstToken for RDollar { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + R_DOLLAR => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { + Some(Self { syntax }) + } else { + None + } + } + fn syntax(&self) -> &SyntaxToken { + &self.syntax + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct SourceFile { pub(crate) syntax: SyntaxNode, } diff --git a/xtask/src/codegen/gen_syntax.rs b/xtask/src/codegen/gen_syntax.rs index c730c75eed..2dfb683718 100644 --- a/xtask/src/codegen/gen_syntax.rs +++ b/xtask/src/codegen/gen_syntax.rs @@ -97,11 +97,13 @@ fn generate_ast(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result { let name = format_ident!("{}", to_pascal_case(kind_str)); quote! { #[derive(Debug, Clone, PartialEq, Eq, Hash)] - pub struct #name(SyntaxToken); + pub struct #name { + pub(crate) syntax: 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) + std::fmt::Display::fmt(&self.syntax, f) } } @@ -112,29 +114,10 @@ fn generate_ast(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result { _ => 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) + fn cast(syntax: SyntaxToken) -> Option { + if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None } } + fn syntax(&self) -> &SyntaxToken { &self.syntax } } } }); @@ -156,28 +139,21 @@ fn generate_ast(kinds: KindsSrc<'_>, 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) -> #iter<#ty> { - #iter::new(&self.syntax) + pub fn #method_name(&self) -> AstChildren<#ty> { + AstChildren::new(&self.syntax) } } } FieldSrc::Optional(_) | FieldSrc::Shorthand => { quote! { pub fn #method_name(&self) -> Option<#ty> { - #iter::new(&self.syntax).next() + AstChildren::new(&self.syntax).next() } } } @@ -203,29 +179,10 @@ fn generate_ast(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result { _ => false, } } - fn cast_or_return(syntax: SyntaxNode) -> Result { - if Self::can_cast(syntax.kind()) { Ok(Self { syntax }) } else { Err(syntax) } + fn cast(syntax: SyntaxNode) -> Option { + if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None } } 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)* @@ -238,71 +195,16 @@ fn generate_ast(kinds: KindsSrc<'_>, 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 = en.variants + let kinds = variants .iter() - .map(|name| { - element_kinds_map[*name].kinds.iter().collect::>() - }) + .map(|name| format_ident!("{}", to_upper_snake_case(&name.to_string()))) .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 { @@ -319,48 +221,34 @@ fn generate_ast(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result { impl std::fmt::Display for #name { fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - match self { - #( - #name::#variants(it) => std::fmt::Display::fmt(it, f), - )* - } + std::fmt::Display::fmt(self.syntax(), f) } } - #specific_ast_trait - - impl AstElement for #name { - fn can_cast_element(kind: SyntaxKind) -> bool { + impl AstNode for #name { + fn can_cast(kind: SyntaxKind) -> bool { match kind { - #(#all_kinds)|* => true, + #(#kinds)|* => true, _ => false, } } - #[allow(unreachable_patterns)] - fn cast_or_return_element(syntax: SyntaxElement) -> Result { - match syntax.kind() { + fn cast(syntax: SyntaxNode) -> Option { + let res = match syntax.kind() { #( - #(#kinds)|* => #variants::cast_or_return_element(syntax).map(|x| #name::#variants(x)), + #kinds => #name::#variants(#variants { syntax }), )* - _ => Err(syntax), - } + _ => return None, + }; + Some(res) } - fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken> { + fn syntax(&self) -> &SyntaxNode { match self { #( - #name::#variants(it) => it.syntax_element(), - )* - } - } - fn into_syntax_element(self) -> SyntaxElement { - match self { - #( - #name::#variants(it) => it.into_syntax_element(), + #name::#variants(it) => &it.syntax, )* } } } - #(#traits)* } }); @@ -380,7 +268,7 @@ fn generate_ast(kinds: KindsSrc<'_>, grammar: AstSrc<'_>) -> Result { #[allow(unused_imports)] use crate::{ SyntaxNode, SyntaxToken, SyntaxElement, NodeOrToken, SyntaxKind::{self, *}, - ast::{self, AstNode, AstToken, AstElement, AstChildren, AstChildTokens, AstChildElements}, + ast::{self, AstNode, AstToken, AstChildren}, }; #(#tokens)*