From 8f01e62bb962fbe282344125f6ace54326efcaa3 Mon Sep 17 00:00:00 2001
From: Aleksey Kladov <aleksey.kladov@gmail.com>
Date: Thu, 9 Apr 2020 10:47:05 +0200
Subject: Scale back the traits

---
 crates/ra_syntax/src/ast.rs           |  108 +-
 crates/ra_syntax/src/ast/generated.rs | 3030 ++++++++++++++++++++++++++++++++-
 2 files changed, 3033 insertions(+), 105 deletions(-)

(limited to 'crates/ra_syntax/src')

diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index 1ac0201b8..ab0f44dd2 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<Self, SyntaxNode>
-    where
-        Self: Sized;
-
     fn cast(syntax: SyntaxNode) -> Option<Self>
     where
-        Self: Sized,
-    {
-        <Self as AstNode>::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<Self, SyntaxToken>
-    where
-        Self: Sized;
-
     fn cast(syntax: SyntaxToken) -> Option<Self>
     where
-        Self: Sized,
-    {
-        <Self as AstToken>::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<Self, SyntaxElement>
-    where
-        Self: Sized;
-
-    fn cast_element(syntax: SyntaxElement) -> Option<Self>
-    where
-        Self: Sized,
-    {
-        <Self as AstElement>::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<N> {
@@ -132,64 +92,6 @@ fn children<P: AstNode + ?Sized, C: AstNode>(parent: &P) -> AstChildren<C> {
     AstChildren::new(parent.syntax())
 }
 
-/// An iterator over `SyntaxToken` children of a particular AST type.
-#[derive(Debug, Clone)]
-pub struct AstChildTokens<N> {
-    inner: SyntaxElementChildren,
-    ph: PhantomData<N>,
-}
-
-impl<N> AstChildTokens<N> {
-    fn new(parent: &SyntaxNode) -> Self {
-        AstChildTokens { inner: parent.children_with_tokens(), ph: PhantomData }
-    }
-}
-
-impl<N: AstToken> Iterator for AstChildTokens<N> {
-    type Item = N;
-    fn next(&mut self) -> Option<N> {
-        self.inner.by_ref().filter_map(|x| x.into_token()).find_map(N::cast)
-    }
-}
-
-fn child_token_opt<P: AstNode + ?Sized, C: AstToken>(parent: &P) -> Option<C> {
-    child_tokens(parent).next()
-}
-
-fn child_tokens<P: AstNode + ?Sized, C: AstToken>(parent: &P) -> AstChildTokens<C> {
-    AstChildTokens::new(parent.syntax())
-}
-
-/// An iterator over `SyntaxNode` children of a particular AST type.
-#[derive(Debug, Clone)]
-pub struct AstChildElements<N> {
-    inner: SyntaxElementChildren,
-    ph: PhantomData<N>,
-}
-
-impl<N> AstChildElements<N> {
-    fn new(parent: &SyntaxNode) -> Self {
-        AstChildElements { inner: parent.children_with_tokens(), ph: PhantomData }
-    }
-}
-
-impl<N: AstElement> Iterator for AstChildElements<N> {
-    type Item = N;
-    fn next(&mut self) -> Option<N> {
-        self.inner.by_ref().find_map(N::cast_element)
-    }
-}
-
-#[allow(dead_code)]
-fn child_element_opt<P: AstNode + ?Sized, C: AstElement>(parent: &P) -> Option<C> {
-    child_elements(parent).next()
-}
-
-#[allow(dead_code)]
-fn child_elements<P: AstNode + ?Sized, C: AstElement>(parent: &P) -> AstChildElements<C> {
-    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 0c339b987..385fddc89 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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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<Self> {
+        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,
 }
-- 
cgit v1.2.3