From 68196ccc10c60de52bb771d295879456f73ede95 Mon Sep 17 00:00:00 2001 From: Luca Barbieri Date: Fri, 3 Apr 2020 21:12:08 +0200 Subject: Add AstElement trait, generate tokens, support tokens in enums - Adds a new AstElement trait that is implemented by all generated node, token and enum structs - Overhauls the code generators to code-generate all tokens, and also enhances enums to support including tokens, node, and nested enums --- crates/ra_syntax/src/ast.rs | 114 +++++++++++++++++++++++++++++++++++-- crates/ra_syntax/src/ast/tokens.rs | 62 +------------------- 2 files changed, 111 insertions(+), 65 deletions(-) (limited to 'crates/ra_syntax') diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs index 26fafb469..1ac0201b8 100644 --- a/crates/ra_syntax/src/ast.rs +++ b/crates/ra_syntax/src/ast.rs @@ -11,7 +11,10 @@ pub mod make; use std::marker::PhantomData; use crate::{ - syntax_node::{SyntaxNode, SyntaxNodeChildren, SyntaxToken}, + syntax_node::{ + NodeOrToken, SyntaxElement, SyntaxElementChildren, SyntaxNode, SyntaxNodeChildren, + SyntaxToken, + }, SmolStr, SyntaxKind, }; @@ -30,16 +33,24 @@ pub use self::{ /// conversion itself has zero runtime cost: ast and syntax nodes have exactly /// the same representation: a pointer to the tree root and a pointer to the /// node itself. -pub trait AstNode: std::fmt::Display { +pub trait AstNode: AstElement { fn can_cast(kind: SyntaxKind) -> bool where Self: Sized; - fn cast(syntax: SyntaxNode) -> Option + fn cast_or_return(syntax: SyntaxNode) -> Result where Self: Sized; + fn cast(syntax: SyntaxNode) -> Option + where + Self: Sized, + { + ::cast_or_return(syntax).ok() + } + fn syntax(&self) -> &SyntaxNode; + fn into_syntax(self) -> SyntaxNode; } #[test] @@ -48,16 +59,51 @@ fn assert_ast_is_object_safe() { } /// Like `AstNode`, but wraps tokens rather than interior nodes. -pub trait AstToken { - fn cast(token: SyntaxToken) -> Option +pub trait AstToken: AstElement { + fn can_cast(token: SyntaxKind) -> bool where Self: Sized; + + fn cast_or_return(syntax: SyntaxToken) -> Result + where + Self: Sized; + + fn cast(syntax: SyntaxToken) -> Option + where + Self: Sized, + { + ::cast_or_return(syntax).ok() + } + fn syntax(&self) -> &SyntaxToken; + fn into_syntax(self) -> SyntaxToken; + fn text(&self) -> &SmolStr { self.syntax().text() } } +/// Like `AstNode`, but wraps either nodes or tokens rather than interior nodes. +pub trait AstElement: std::fmt::Display { + fn can_cast_element(kind: SyntaxKind) -> bool + where + Self: Sized; + + fn cast_or_return_element(syntax: SyntaxElement) -> Result + where + Self: Sized; + + fn cast_element(syntax: SyntaxElement) -> Option + where + Self: Sized, + { + ::cast_or_return_element(syntax).ok() + } + + fn syntax_element(&self) -> NodeOrToken<&SyntaxNode, &SyntaxToken>; + fn into_syntax_element(self) -> SyntaxElement; +} + /// An iterator over `SyntaxNode` children of a particular AST type. #[derive(Debug, Clone)] pub struct AstChildren { @@ -86,6 +132,64 @@ fn children(parent: &P) -> AstChildren { AstChildren::new(parent.syntax()) } +/// An iterator over `SyntaxToken` children of a particular AST type. +#[derive(Debug, Clone)] +pub struct AstChildTokens { + inner: SyntaxElementChildren, + ph: PhantomData, +} + +impl AstChildTokens { + fn new(parent: &SyntaxNode) -> Self { + AstChildTokens { inner: parent.children_with_tokens(), ph: PhantomData } + } +} + +impl Iterator for AstChildTokens { + type Item = N; + fn next(&mut self) -> Option { + self.inner.by_ref().filter_map(|x| x.into_token()).find_map(N::cast) + } +} + +fn child_token_opt(parent: &P) -> Option { + child_tokens(parent).next() +} + +fn child_tokens(parent: &P) -> AstChildTokens { + AstChildTokens::new(parent.syntax()) +} + +/// An iterator over `SyntaxNode` children of a particular AST type. +#[derive(Debug, Clone)] +pub struct AstChildElements { + inner: SyntaxElementChildren, + ph: PhantomData, +} + +impl AstChildElements { + fn new(parent: &SyntaxNode) -> Self { + AstChildElements { inner: parent.children_with_tokens(), ph: PhantomData } + } +} + +impl Iterator for AstChildElements { + type Item = N; + fn next(&mut self) -> Option { + self.inner.by_ref().find_map(N::cast_element) + } +} + +#[allow(dead_code)] +fn child_element_opt(parent: &P) -> Option { + child_elements(parent).next() +} + +#[allow(dead_code)] +fn child_elements(parent: &P) -> AstChildElements { + AstChildElements::new(parent.syntax()) +} + #[test] fn test_doc_comment_none() { let file = SourceFile::parse( diff --git a/crates/ra_syntax/src/ast/tokens.rs b/crates/ra_syntax/src/ast/tokens.rs index 1a51b8d3b..e8320b57e 100644 --- a/crates/ra_syntax/src/ast/tokens.rs +++ b/crates/ra_syntax/src/ast/tokens.rs @@ -1,26 +1,10 @@ //! There are many AstNodes, but only a few tokens, so we hand-write them here. use crate::{ - ast::AstToken, - SyntaxKind::{COMMENT, RAW_STRING, STRING, WHITESPACE}, - SyntaxToken, TextRange, TextUnit, + ast::{AstToken, Comment, RawString, String, Whitespace}, + TextRange, TextUnit, }; -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Comment(SyntaxToken); - -impl AstToken for Comment { - fn cast(token: SyntaxToken) -> Option { - match token.kind() { - COMMENT => Some(Comment(token)), - _ => None, - } - } - fn syntax(&self) -> &SyntaxToken { - &self.0 - } -} - impl Comment { pub fn kind(&self) -> CommentKind { kind_by_prefix(self.text()) @@ -89,20 +73,6 @@ fn prefix_by_kind(kind: CommentKind) -> &'static str { unreachable!() } -pub struct Whitespace(SyntaxToken); - -impl AstToken for Whitespace { - fn cast(token: SyntaxToken) -> Option { - match token.kind() { - WHITESPACE => Some(Whitespace(token)), - _ => None, - } - } - fn syntax(&self) -> &SyntaxToken { - &self.0 - } -} - impl Whitespace { pub fn spans_multiple_lines(&self) -> bool { let text = self.text(); @@ -168,20 +138,6 @@ pub trait HasStringValue: HasQuotes { fn value(&self) -> Option; } -pub struct String(SyntaxToken); - -impl AstToken for String { - fn cast(token: SyntaxToken) -> Option { - match token.kind() { - STRING => Some(String(token)), - _ => None, - } - } - fn syntax(&self) -> &SyntaxToken { - &self.0 - } -} - impl HasStringValue for String { fn value(&self) -> Option { let text = self.text().as_str(); @@ -201,20 +157,6 @@ impl HasStringValue for String { } } -pub struct RawString(SyntaxToken); - -impl AstToken for RawString { - fn cast(token: SyntaxToken) -> Option { - match token.kind() { - RAW_STRING => Some(RawString(token)), - _ => None, - } - } - fn syntax(&self) -> &SyntaxToken { - &self.0 - } -} - impl HasStringValue for RawString { fn value(&self) -> Option { let text = self.text().as_str(); -- cgit v1.2.3 From 8f01e62bb962fbe282344125f6ace54326efcaa3 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov 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') 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 - 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 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 { + if 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, } -- cgit v1.2.3