From 4a063e651f0ec0da852ce1f87589d5c0a893c59d Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Thu, 9 Apr 2020 17:58:15 +0200 Subject: Move the rest of the tokens to generated/tokens --- crates/ra_syntax/src/ast/generated/nodes.rs | 655 +-------------------------- crates/ra_syntax/src/ast/generated/tokens.rs | 651 ++++++++++++++++++++++++++ 2 files changed, 653 insertions(+), 653 deletions(-) (limited to 'crates/ra_syntax/src/ast/generated') diff --git a/crates/ra_syntax/src/ast/generated/nodes.rs b/crates/ra_syntax/src/ast/generated/nodes.rs index 7d74c9fc9..18bf30657 100644 --- a/crates/ra_syntax/src/ast/generated/nodes.rs +++ b/crates/ra_syntax/src/ast/generated/nodes.rs @@ -2,9 +2,9 @@ use super::tokens::*; use crate::{ - ast::{self, support, AstChildren, AstNode, AstToken}, + ast::{self, support, AstChildren, AstNode}, SyntaxKind::{self, *}, - SyntaxNode, SyntaxToken, + SyntaxNode, }; #[derive(Debug, Clone, PartialEq, Eq, Hash)] pub struct SourceFile { @@ -5877,657 +5877,6 @@ impl AstNode for Stmt { } } #[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum LeftDelimiter { - LParen(LParen), - LBrack(LBrack), - LCurly(LCurly), -} -impl From for LeftDelimiter { - fn from(node: LParen) -> LeftDelimiter { - LeftDelimiter::LParen(node) - } -} -impl From for LeftDelimiter { - fn from(node: LBrack) -> LeftDelimiter { - LeftDelimiter::LBrack(node) - } -} -impl From for LeftDelimiter { - fn from(node: LCurly) -> LeftDelimiter { - LeftDelimiter::LCurly(node) - } -} -impl std::fmt::Display for LeftDelimiter { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstToken for LeftDelimiter { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - L_PAREN | L_BRACK | L_CURLY => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - let res = match syntax.kind() { - L_PAREN => LeftDelimiter::LParen(LParen { syntax }), - L_BRACK => LeftDelimiter::LBrack(LBrack { syntax }), - L_CURLY => LeftDelimiter::LCurly(LCurly { syntax }), - _ => return None, - }; - Some(res) - } - fn syntax(&self) -> &SyntaxToken { - match self { - LeftDelimiter::LParen(it) => &it.syntax, - LeftDelimiter::LBrack(it) => &it.syntax, - LeftDelimiter::LCurly(it) => &it.syntax, - } - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum RightDelimiter { - RParen(RParen), - RBrack(RBrack), - RCurly(RCurly), -} -impl From for RightDelimiter { - fn from(node: RParen) -> RightDelimiter { - RightDelimiter::RParen(node) - } -} -impl From for RightDelimiter { - fn from(node: RBrack) -> RightDelimiter { - RightDelimiter::RBrack(node) - } -} -impl From for RightDelimiter { - fn from(node: RCurly) -> RightDelimiter { - RightDelimiter::RCurly(node) - } -} -impl std::fmt::Display for RightDelimiter { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstToken for RightDelimiter { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - R_PAREN | R_BRACK | R_CURLY => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - let res = match syntax.kind() { - R_PAREN => RightDelimiter::RParen(RParen { syntax }), - R_BRACK => RightDelimiter::RBrack(RBrack { syntax }), - R_CURLY => RightDelimiter::RCurly(RCurly { syntax }), - _ => return None, - }; - Some(res) - } - fn syntax(&self) -> &SyntaxToken { - match self { - RightDelimiter::RParen(it) => &it.syntax, - RightDelimiter::RBrack(it) => &it.syntax, - RightDelimiter::RCurly(it) => &it.syntax, - } - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum RangeSeparator { - Dotdot(Dotdot), - Dotdotdot(Dotdotdot), - Dotdoteq(Dotdoteq), -} -impl From for RangeSeparator { - fn from(node: Dotdot) -> RangeSeparator { - RangeSeparator::Dotdot(node) - } -} -impl From for RangeSeparator { - fn from(node: Dotdotdot) -> RangeSeparator { - RangeSeparator::Dotdotdot(node) - } -} -impl From for RangeSeparator { - fn from(node: Dotdoteq) -> RangeSeparator { - RangeSeparator::Dotdoteq(node) - } -} -impl std::fmt::Display for RangeSeparator { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstToken for RangeSeparator { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - DOTDOT | DOTDOTDOT | DOTDOTEQ => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - let res = match syntax.kind() { - DOTDOT => RangeSeparator::Dotdot(Dotdot { syntax }), - DOTDOTDOT => RangeSeparator::Dotdotdot(Dotdotdot { syntax }), - DOTDOTEQ => RangeSeparator::Dotdoteq(Dotdoteq { syntax }), - _ => return None, - }; - Some(res) - } - fn syntax(&self) -> &SyntaxToken { - match self { - RangeSeparator::Dotdot(it) => &it.syntax, - RangeSeparator::Dotdotdot(it) => &it.syntax, - RangeSeparator::Dotdoteq(it) => &it.syntax, - } - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum BinOp { - Pipepipe(Pipepipe), - Ampamp(Ampamp), - Eqeq(Eqeq), - Neq(Neq), - Lteq(Lteq), - Gteq(Gteq), - LAngle(LAngle), - RAngle(RAngle), - Plus(Plus), - Star(Star), - Minus(Minus), - Slash(Slash), - Percent(Percent), - Shl(Shl), - Shr(Shr), - Caret(Caret), - Pipe(Pipe), - Amp(Amp), - Eq(Eq), - Pluseq(Pluseq), - Slasheq(Slasheq), - Stareq(Stareq), - Percenteq(Percenteq), - Shreq(Shreq), - Shleq(Shleq), - Minuseq(Minuseq), - Pipeeq(Pipeeq), - Ampeq(Ampeq), - Careteq(Careteq), -} -impl From for BinOp { - fn from(node: Pipepipe) -> BinOp { - BinOp::Pipepipe(node) - } -} -impl From for BinOp { - fn from(node: Ampamp) -> BinOp { - BinOp::Ampamp(node) - } -} -impl From for BinOp { - fn from(node: Eqeq) -> BinOp { - BinOp::Eqeq(node) - } -} -impl From for BinOp { - fn from(node: Neq) -> BinOp { - BinOp::Neq(node) - } -} -impl From for BinOp { - fn from(node: Lteq) -> BinOp { - BinOp::Lteq(node) - } -} -impl From for BinOp { - fn from(node: Gteq) -> BinOp { - BinOp::Gteq(node) - } -} -impl From for BinOp { - fn from(node: LAngle) -> BinOp { - BinOp::LAngle(node) - } -} -impl From for BinOp { - fn from(node: RAngle) -> BinOp { - BinOp::RAngle(node) - } -} -impl From for BinOp { - fn from(node: Plus) -> BinOp { - BinOp::Plus(node) - } -} -impl From for BinOp { - fn from(node: Star) -> BinOp { - BinOp::Star(node) - } -} -impl From for BinOp { - fn from(node: Minus) -> BinOp { - BinOp::Minus(node) - } -} -impl From for BinOp { - fn from(node: Slash) -> BinOp { - BinOp::Slash(node) - } -} -impl From for BinOp { - fn from(node: Percent) -> BinOp { - BinOp::Percent(node) - } -} -impl From for BinOp { - fn from(node: Shl) -> BinOp { - BinOp::Shl(node) - } -} -impl From for BinOp { - fn from(node: Shr) -> BinOp { - BinOp::Shr(node) - } -} -impl From for BinOp { - fn from(node: Caret) -> BinOp { - BinOp::Caret(node) - } -} -impl From for BinOp { - fn from(node: Pipe) -> BinOp { - BinOp::Pipe(node) - } -} -impl From for BinOp { - fn from(node: Amp) -> BinOp { - BinOp::Amp(node) - } -} -impl From for BinOp { - fn from(node: Eq) -> BinOp { - BinOp::Eq(node) - } -} -impl From for BinOp { - fn from(node: Pluseq) -> BinOp { - BinOp::Pluseq(node) - } -} -impl From for BinOp { - fn from(node: Slasheq) -> BinOp { - BinOp::Slasheq(node) - } -} -impl From for BinOp { - fn from(node: Stareq) -> BinOp { - BinOp::Stareq(node) - } -} -impl From for BinOp { - fn from(node: Percenteq) -> BinOp { - BinOp::Percenteq(node) - } -} -impl From for BinOp { - fn from(node: Shreq) -> BinOp { - BinOp::Shreq(node) - } -} -impl From for BinOp { - fn from(node: Shleq) -> BinOp { - BinOp::Shleq(node) - } -} -impl From for BinOp { - fn from(node: Minuseq) -> BinOp { - BinOp::Minuseq(node) - } -} -impl From for BinOp { - fn from(node: Pipeeq) -> BinOp { - BinOp::Pipeeq(node) - } -} -impl From for BinOp { - fn from(node: Ampeq) -> BinOp { - BinOp::Ampeq(node) - } -} -impl From for BinOp { - fn from(node: Careteq) -> BinOp { - BinOp::Careteq(node) - } -} -impl std::fmt::Display for BinOp { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstToken for BinOp { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - PIPEPIPE | AMPAMP | EQEQ | NEQ | LTEQ | GTEQ | L_ANGLE | R_ANGLE | PLUS | STAR - | MINUS | SLASH | PERCENT | SHL | SHR | CARET | PIPE | AMP | EQ | PLUSEQ | SLASHEQ - | STAREQ | PERCENTEQ | SHREQ | SHLEQ | MINUSEQ | PIPEEQ | AMPEQ | CARETEQ => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - let res = match syntax.kind() { - PIPEPIPE => BinOp::Pipepipe(Pipepipe { syntax }), - AMPAMP => BinOp::Ampamp(Ampamp { syntax }), - EQEQ => BinOp::Eqeq(Eqeq { syntax }), - NEQ => BinOp::Neq(Neq { syntax }), - LTEQ => BinOp::Lteq(Lteq { syntax }), - GTEQ => BinOp::Gteq(Gteq { syntax }), - L_ANGLE => BinOp::LAngle(LAngle { syntax }), - R_ANGLE => BinOp::RAngle(RAngle { syntax }), - PLUS => BinOp::Plus(Plus { syntax }), - STAR => BinOp::Star(Star { syntax }), - MINUS => BinOp::Minus(Minus { syntax }), - SLASH => BinOp::Slash(Slash { syntax }), - PERCENT => BinOp::Percent(Percent { syntax }), - SHL => BinOp::Shl(Shl { syntax }), - SHR => BinOp::Shr(Shr { syntax }), - CARET => BinOp::Caret(Caret { syntax }), - PIPE => BinOp::Pipe(Pipe { syntax }), - AMP => BinOp::Amp(Amp { syntax }), - EQ => BinOp::Eq(Eq { syntax }), - PLUSEQ => BinOp::Pluseq(Pluseq { syntax }), - SLASHEQ => BinOp::Slasheq(Slasheq { syntax }), - STAREQ => BinOp::Stareq(Stareq { syntax }), - PERCENTEQ => BinOp::Percenteq(Percenteq { syntax }), - SHREQ => BinOp::Shreq(Shreq { syntax }), - SHLEQ => BinOp::Shleq(Shleq { syntax }), - MINUSEQ => BinOp::Minuseq(Minuseq { syntax }), - PIPEEQ => BinOp::Pipeeq(Pipeeq { syntax }), - AMPEQ => BinOp::Ampeq(Ampeq { syntax }), - CARETEQ => BinOp::Careteq(Careteq { syntax }), - _ => return None, - }; - Some(res) - } - fn syntax(&self) -> &SyntaxToken { - match self { - BinOp::Pipepipe(it) => &it.syntax, - BinOp::Ampamp(it) => &it.syntax, - BinOp::Eqeq(it) => &it.syntax, - BinOp::Neq(it) => &it.syntax, - BinOp::Lteq(it) => &it.syntax, - BinOp::Gteq(it) => &it.syntax, - BinOp::LAngle(it) => &it.syntax, - BinOp::RAngle(it) => &it.syntax, - BinOp::Plus(it) => &it.syntax, - BinOp::Star(it) => &it.syntax, - BinOp::Minus(it) => &it.syntax, - BinOp::Slash(it) => &it.syntax, - BinOp::Percent(it) => &it.syntax, - BinOp::Shl(it) => &it.syntax, - BinOp::Shr(it) => &it.syntax, - BinOp::Caret(it) => &it.syntax, - BinOp::Pipe(it) => &it.syntax, - BinOp::Amp(it) => &it.syntax, - BinOp::Eq(it) => &it.syntax, - BinOp::Pluseq(it) => &it.syntax, - BinOp::Slasheq(it) => &it.syntax, - BinOp::Stareq(it) => &it.syntax, - BinOp::Percenteq(it) => &it.syntax, - BinOp::Shreq(it) => &it.syntax, - BinOp::Shleq(it) => &it.syntax, - BinOp::Minuseq(it) => &it.syntax, - BinOp::Pipeeq(it) => &it.syntax, - BinOp::Ampeq(it) => &it.syntax, - BinOp::Careteq(it) => &it.syntax, - } - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum PrefixOp { - Minus(Minus), - Excl(Excl), - Star(Star), -} -impl From for PrefixOp { - fn from(node: Minus) -> PrefixOp { - PrefixOp::Minus(node) - } -} -impl From for PrefixOp { - fn from(node: Excl) -> PrefixOp { - PrefixOp::Excl(node) - } -} -impl From for PrefixOp { - fn from(node: Star) -> PrefixOp { - PrefixOp::Star(node) - } -} -impl std::fmt::Display for PrefixOp { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstToken for PrefixOp { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - MINUS | EXCL | STAR => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - let res = match syntax.kind() { - MINUS => PrefixOp::Minus(Minus { syntax }), - EXCL => PrefixOp::Excl(Excl { syntax }), - STAR => PrefixOp::Star(Star { syntax }), - _ => return None, - }; - Some(res) - } - fn syntax(&self) -> &SyntaxToken { - match self { - PrefixOp::Minus(it) => &it.syntax, - PrefixOp::Excl(it) => &it.syntax, - PrefixOp::Star(it) => &it.syntax, - } - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum RangeOp { - Dotdot(Dotdot), - Dotdoteq(Dotdoteq), -} -impl From for RangeOp { - fn from(node: Dotdot) -> RangeOp { - RangeOp::Dotdot(node) - } -} -impl From for RangeOp { - fn from(node: Dotdoteq) -> RangeOp { - RangeOp::Dotdoteq(node) - } -} -impl std::fmt::Display for RangeOp { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstToken for RangeOp { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - DOTDOT | DOTDOTEQ => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - let res = match syntax.kind() { - DOTDOT => RangeOp::Dotdot(Dotdot { syntax }), - DOTDOTEQ => RangeOp::Dotdoteq(Dotdoteq { syntax }), - _ => return None, - }; - Some(res) - } - fn syntax(&self) -> &SyntaxToken { - match self { - RangeOp::Dotdot(it) => &it.syntax, - RangeOp::Dotdoteq(it) => &it.syntax, - } - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum LiteralToken { - IntNumber(IntNumber), - FloatNumber(FloatNumber), - String(String), - RawString(RawString), - TrueKw(TrueKw), - FalseKw(FalseKw), - ByteString(ByteString), - RawByteString(RawByteString), - Char(Char), - Byte(Byte), -} -impl From for LiteralToken { - fn from(node: IntNumber) -> LiteralToken { - LiteralToken::IntNumber(node) - } -} -impl From for LiteralToken { - fn from(node: FloatNumber) -> LiteralToken { - LiteralToken::FloatNumber(node) - } -} -impl From for LiteralToken { - fn from(node: String) -> LiteralToken { - LiteralToken::String(node) - } -} -impl From for LiteralToken { - fn from(node: RawString) -> LiteralToken { - LiteralToken::RawString(node) - } -} -impl From for LiteralToken { - fn from(node: TrueKw) -> LiteralToken { - LiteralToken::TrueKw(node) - } -} -impl From for LiteralToken { - fn from(node: FalseKw) -> LiteralToken { - LiteralToken::FalseKw(node) - } -} -impl From for LiteralToken { - fn from(node: ByteString) -> LiteralToken { - LiteralToken::ByteString(node) - } -} -impl From for LiteralToken { - fn from(node: RawByteString) -> LiteralToken { - LiteralToken::RawByteString(node) - } -} -impl From for LiteralToken { - fn from(node: Char) -> LiteralToken { - LiteralToken::Char(node) - } -} -impl From for LiteralToken { - fn from(node: Byte) -> LiteralToken { - LiteralToken::Byte(node) - } -} -impl std::fmt::Display for LiteralToken { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstToken for LiteralToken { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - INT_NUMBER | FLOAT_NUMBER | STRING | RAW_STRING | TRUE_KW | FALSE_KW | BYTE_STRING - | RAW_BYTE_STRING | CHAR | BYTE => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - let res = match syntax.kind() { - INT_NUMBER => LiteralToken::IntNumber(IntNumber { syntax }), - FLOAT_NUMBER => LiteralToken::FloatNumber(FloatNumber { syntax }), - STRING => LiteralToken::String(String { syntax }), - RAW_STRING => LiteralToken::RawString(RawString { syntax }), - TRUE_KW => LiteralToken::TrueKw(TrueKw { syntax }), - FALSE_KW => LiteralToken::FalseKw(FalseKw { syntax }), - BYTE_STRING => LiteralToken::ByteString(ByteString { syntax }), - RAW_BYTE_STRING => LiteralToken::RawByteString(RawByteString { syntax }), - CHAR => LiteralToken::Char(Char { syntax }), - BYTE => LiteralToken::Byte(Byte { syntax }), - _ => return None, - }; - Some(res) - } - fn syntax(&self) -> &SyntaxToken { - match self { - LiteralToken::IntNumber(it) => &it.syntax, - LiteralToken::FloatNumber(it) => &it.syntax, - LiteralToken::String(it) => &it.syntax, - LiteralToken::RawString(it) => &it.syntax, - LiteralToken::TrueKw(it) => &it.syntax, - LiteralToken::FalseKw(it) => &it.syntax, - LiteralToken::ByteString(it) => &it.syntax, - LiteralToken::RawByteString(it) => &it.syntax, - LiteralToken::Char(it) => &it.syntax, - LiteralToken::Byte(it) => &it.syntax, - } - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub enum NameRefToken { - Ident(Ident), - IntNumber(IntNumber), -} -impl From for NameRefToken { - fn from(node: Ident) -> NameRefToken { - NameRefToken::Ident(node) - } -} -impl From for NameRefToken { - fn from(node: IntNumber) -> NameRefToken { - NameRefToken::IntNumber(node) - } -} -impl std::fmt::Display for NameRefToken { - fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { - std::fmt::Display::fmt(self.syntax(), f) - } -} -impl AstToken for NameRefToken { - fn can_cast(kind: SyntaxKind) -> bool { - match kind { - IDENT | INT_NUMBER => true, - _ => false, - } - } - fn cast(syntax: SyntaxToken) -> Option { - let res = match syntax.kind() { - IDENT => NameRefToken::Ident(Ident { syntax }), - INT_NUMBER => NameRefToken::IntNumber(IntNumber { syntax }), - _ => return None, - }; - Some(res) - } - fn syntax(&self) -> &SyntaxToken { - match self { - NameRefToken::Ident(it) => &it.syntax, - NameRefToken::IntNumber(it) => &it.syntax, - } - } -} -#[derive(Debug, Clone, PartialEq, Eq, Hash)] pub enum FieldDefList { RecordFieldDefList(RecordFieldDefList), TupleFieldDefList(TupleFieldDefList), diff --git a/crates/ra_syntax/src/ast/generated/tokens.rs b/crates/ra_syntax/src/ast/generated/tokens.rs index 27b2d2977..3aea5bef1 100644 --- a/crates/ra_syntax/src/ast/generated/tokens.rs +++ b/crates/ra_syntax/src/ast/generated/tokens.rs @@ -3056,3 +3056,654 @@ impl AstToken for RDollar { &self.syntax } } +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum LeftDelimiter { + LParen(LParen), + LBrack(LBrack), + LCurly(LCurly), +} +impl From for LeftDelimiter { + fn from(node: LParen) -> LeftDelimiter { + LeftDelimiter::LParen(node) + } +} +impl From for LeftDelimiter { + fn from(node: LBrack) -> LeftDelimiter { + LeftDelimiter::LBrack(node) + } +} +impl From for LeftDelimiter { + fn from(node: LCurly) -> LeftDelimiter { + LeftDelimiter::LCurly(node) + } +} +impl std::fmt::Display for LeftDelimiter { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} +impl AstToken for LeftDelimiter { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + L_PAREN | L_BRACK | L_CURLY => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + let res = match syntax.kind() { + L_PAREN => LeftDelimiter::LParen(LParen { syntax }), + L_BRACK => LeftDelimiter::LBrack(LBrack { syntax }), + L_CURLY => LeftDelimiter::LCurly(LCurly { syntax }), + _ => return None, + }; + Some(res) + } + fn syntax(&self) -> &SyntaxToken { + match self { + LeftDelimiter::LParen(it) => &it.syntax, + LeftDelimiter::LBrack(it) => &it.syntax, + LeftDelimiter::LCurly(it) => &it.syntax, + } + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum RightDelimiter { + RParen(RParen), + RBrack(RBrack), + RCurly(RCurly), +} +impl From for RightDelimiter { + fn from(node: RParen) -> RightDelimiter { + RightDelimiter::RParen(node) + } +} +impl From for RightDelimiter { + fn from(node: RBrack) -> RightDelimiter { + RightDelimiter::RBrack(node) + } +} +impl From for RightDelimiter { + fn from(node: RCurly) -> RightDelimiter { + RightDelimiter::RCurly(node) + } +} +impl std::fmt::Display for RightDelimiter { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} +impl AstToken for RightDelimiter { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + R_PAREN | R_BRACK | R_CURLY => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + let res = match syntax.kind() { + R_PAREN => RightDelimiter::RParen(RParen { syntax }), + R_BRACK => RightDelimiter::RBrack(RBrack { syntax }), + R_CURLY => RightDelimiter::RCurly(RCurly { syntax }), + _ => return None, + }; + Some(res) + } + fn syntax(&self) -> &SyntaxToken { + match self { + RightDelimiter::RParen(it) => &it.syntax, + RightDelimiter::RBrack(it) => &it.syntax, + RightDelimiter::RCurly(it) => &it.syntax, + } + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum RangeSeparator { + Dotdot(Dotdot), + Dotdotdot(Dotdotdot), + Dotdoteq(Dotdoteq), +} +impl From for RangeSeparator { + fn from(node: Dotdot) -> RangeSeparator { + RangeSeparator::Dotdot(node) + } +} +impl From for RangeSeparator { + fn from(node: Dotdotdot) -> RangeSeparator { + RangeSeparator::Dotdotdot(node) + } +} +impl From for RangeSeparator { + fn from(node: Dotdoteq) -> RangeSeparator { + RangeSeparator::Dotdoteq(node) + } +} +impl std::fmt::Display for RangeSeparator { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} +impl AstToken for RangeSeparator { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + DOTDOT | DOTDOTDOT | DOTDOTEQ => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + let res = match syntax.kind() { + DOTDOT => RangeSeparator::Dotdot(Dotdot { syntax }), + DOTDOTDOT => RangeSeparator::Dotdotdot(Dotdotdot { syntax }), + DOTDOTEQ => RangeSeparator::Dotdoteq(Dotdoteq { syntax }), + _ => return None, + }; + Some(res) + } + fn syntax(&self) -> &SyntaxToken { + match self { + RangeSeparator::Dotdot(it) => &it.syntax, + RangeSeparator::Dotdotdot(it) => &it.syntax, + RangeSeparator::Dotdoteq(it) => &it.syntax, + } + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum BinOp { + Pipepipe(Pipepipe), + Ampamp(Ampamp), + Eqeq(Eqeq), + Neq(Neq), + Lteq(Lteq), + Gteq(Gteq), + LAngle(LAngle), + RAngle(RAngle), + Plus(Plus), + Star(Star), + Minus(Minus), + Slash(Slash), + Percent(Percent), + Shl(Shl), + Shr(Shr), + Caret(Caret), + Pipe(Pipe), + Amp(Amp), + Eq(Eq), + Pluseq(Pluseq), + Slasheq(Slasheq), + Stareq(Stareq), + Percenteq(Percenteq), + Shreq(Shreq), + Shleq(Shleq), + Minuseq(Minuseq), + Pipeeq(Pipeeq), + Ampeq(Ampeq), + Careteq(Careteq), +} +impl From for BinOp { + fn from(node: Pipepipe) -> BinOp { + BinOp::Pipepipe(node) + } +} +impl From for BinOp { + fn from(node: Ampamp) -> BinOp { + BinOp::Ampamp(node) + } +} +impl From for BinOp { + fn from(node: Eqeq) -> BinOp { + BinOp::Eqeq(node) + } +} +impl From for BinOp { + fn from(node: Neq) -> BinOp { + BinOp::Neq(node) + } +} +impl From for BinOp { + fn from(node: Lteq) -> BinOp { + BinOp::Lteq(node) + } +} +impl From for BinOp { + fn from(node: Gteq) -> BinOp { + BinOp::Gteq(node) + } +} +impl From for BinOp { + fn from(node: LAngle) -> BinOp { + BinOp::LAngle(node) + } +} +impl From for BinOp { + fn from(node: RAngle) -> BinOp { + BinOp::RAngle(node) + } +} +impl From for BinOp { + fn from(node: Plus) -> BinOp { + BinOp::Plus(node) + } +} +impl From for BinOp { + fn from(node: Star) -> BinOp { + BinOp::Star(node) + } +} +impl From for BinOp { + fn from(node: Minus) -> BinOp { + BinOp::Minus(node) + } +} +impl From for BinOp { + fn from(node: Slash) -> BinOp { + BinOp::Slash(node) + } +} +impl From for BinOp { + fn from(node: Percent) -> BinOp { + BinOp::Percent(node) + } +} +impl From for BinOp { + fn from(node: Shl) -> BinOp { + BinOp::Shl(node) + } +} +impl From for BinOp { + fn from(node: Shr) -> BinOp { + BinOp::Shr(node) + } +} +impl From for BinOp { + fn from(node: Caret) -> BinOp { + BinOp::Caret(node) + } +} +impl From for BinOp { + fn from(node: Pipe) -> BinOp { + BinOp::Pipe(node) + } +} +impl From for BinOp { + fn from(node: Amp) -> BinOp { + BinOp::Amp(node) + } +} +impl From for BinOp { + fn from(node: Eq) -> BinOp { + BinOp::Eq(node) + } +} +impl From for BinOp { + fn from(node: Pluseq) -> BinOp { + BinOp::Pluseq(node) + } +} +impl From for BinOp { + fn from(node: Slasheq) -> BinOp { + BinOp::Slasheq(node) + } +} +impl From for BinOp { + fn from(node: Stareq) -> BinOp { + BinOp::Stareq(node) + } +} +impl From for BinOp { + fn from(node: Percenteq) -> BinOp { + BinOp::Percenteq(node) + } +} +impl From for BinOp { + fn from(node: Shreq) -> BinOp { + BinOp::Shreq(node) + } +} +impl From for BinOp { + fn from(node: Shleq) -> BinOp { + BinOp::Shleq(node) + } +} +impl From for BinOp { + fn from(node: Minuseq) -> BinOp { + BinOp::Minuseq(node) + } +} +impl From for BinOp { + fn from(node: Pipeeq) -> BinOp { + BinOp::Pipeeq(node) + } +} +impl From for BinOp { + fn from(node: Ampeq) -> BinOp { + BinOp::Ampeq(node) + } +} +impl From for BinOp { + fn from(node: Careteq) -> BinOp { + BinOp::Careteq(node) + } +} +impl std::fmt::Display for BinOp { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} +impl AstToken for BinOp { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + PIPEPIPE | AMPAMP | EQEQ | NEQ | LTEQ | GTEQ | L_ANGLE | R_ANGLE | PLUS | STAR + | MINUS | SLASH | PERCENT | SHL | SHR | CARET | PIPE | AMP | EQ | PLUSEQ | SLASHEQ + | STAREQ | PERCENTEQ | SHREQ | SHLEQ | MINUSEQ | PIPEEQ | AMPEQ | CARETEQ => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + let res = match syntax.kind() { + PIPEPIPE => BinOp::Pipepipe(Pipepipe { syntax }), + AMPAMP => BinOp::Ampamp(Ampamp { syntax }), + EQEQ => BinOp::Eqeq(Eqeq { syntax }), + NEQ => BinOp::Neq(Neq { syntax }), + LTEQ => BinOp::Lteq(Lteq { syntax }), + GTEQ => BinOp::Gteq(Gteq { syntax }), + L_ANGLE => BinOp::LAngle(LAngle { syntax }), + R_ANGLE => BinOp::RAngle(RAngle { syntax }), + PLUS => BinOp::Plus(Plus { syntax }), + STAR => BinOp::Star(Star { syntax }), + MINUS => BinOp::Minus(Minus { syntax }), + SLASH => BinOp::Slash(Slash { syntax }), + PERCENT => BinOp::Percent(Percent { syntax }), + SHL => BinOp::Shl(Shl { syntax }), + SHR => BinOp::Shr(Shr { syntax }), + CARET => BinOp::Caret(Caret { syntax }), + PIPE => BinOp::Pipe(Pipe { syntax }), + AMP => BinOp::Amp(Amp { syntax }), + EQ => BinOp::Eq(Eq { syntax }), + PLUSEQ => BinOp::Pluseq(Pluseq { syntax }), + SLASHEQ => BinOp::Slasheq(Slasheq { syntax }), + STAREQ => BinOp::Stareq(Stareq { syntax }), + PERCENTEQ => BinOp::Percenteq(Percenteq { syntax }), + SHREQ => BinOp::Shreq(Shreq { syntax }), + SHLEQ => BinOp::Shleq(Shleq { syntax }), + MINUSEQ => BinOp::Minuseq(Minuseq { syntax }), + PIPEEQ => BinOp::Pipeeq(Pipeeq { syntax }), + AMPEQ => BinOp::Ampeq(Ampeq { syntax }), + CARETEQ => BinOp::Careteq(Careteq { syntax }), + _ => return None, + }; + Some(res) + } + fn syntax(&self) -> &SyntaxToken { + match self { + BinOp::Pipepipe(it) => &it.syntax, + BinOp::Ampamp(it) => &it.syntax, + BinOp::Eqeq(it) => &it.syntax, + BinOp::Neq(it) => &it.syntax, + BinOp::Lteq(it) => &it.syntax, + BinOp::Gteq(it) => &it.syntax, + BinOp::LAngle(it) => &it.syntax, + BinOp::RAngle(it) => &it.syntax, + BinOp::Plus(it) => &it.syntax, + BinOp::Star(it) => &it.syntax, + BinOp::Minus(it) => &it.syntax, + BinOp::Slash(it) => &it.syntax, + BinOp::Percent(it) => &it.syntax, + BinOp::Shl(it) => &it.syntax, + BinOp::Shr(it) => &it.syntax, + BinOp::Caret(it) => &it.syntax, + BinOp::Pipe(it) => &it.syntax, + BinOp::Amp(it) => &it.syntax, + BinOp::Eq(it) => &it.syntax, + BinOp::Pluseq(it) => &it.syntax, + BinOp::Slasheq(it) => &it.syntax, + BinOp::Stareq(it) => &it.syntax, + BinOp::Percenteq(it) => &it.syntax, + BinOp::Shreq(it) => &it.syntax, + BinOp::Shleq(it) => &it.syntax, + BinOp::Minuseq(it) => &it.syntax, + BinOp::Pipeeq(it) => &it.syntax, + BinOp::Ampeq(it) => &it.syntax, + BinOp::Careteq(it) => &it.syntax, + } + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum PrefixOp { + Minus(Minus), + Excl(Excl), + Star(Star), +} +impl From for PrefixOp { + fn from(node: Minus) -> PrefixOp { + PrefixOp::Minus(node) + } +} +impl From for PrefixOp { + fn from(node: Excl) -> PrefixOp { + PrefixOp::Excl(node) + } +} +impl From for PrefixOp { + fn from(node: Star) -> PrefixOp { + PrefixOp::Star(node) + } +} +impl std::fmt::Display for PrefixOp { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} +impl AstToken for PrefixOp { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + MINUS | EXCL | STAR => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + let res = match syntax.kind() { + MINUS => PrefixOp::Minus(Minus { syntax }), + EXCL => PrefixOp::Excl(Excl { syntax }), + STAR => PrefixOp::Star(Star { syntax }), + _ => return None, + }; + Some(res) + } + fn syntax(&self) -> &SyntaxToken { + match self { + PrefixOp::Minus(it) => &it.syntax, + PrefixOp::Excl(it) => &it.syntax, + PrefixOp::Star(it) => &it.syntax, + } + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum RangeOp { + Dotdot(Dotdot), + Dotdoteq(Dotdoteq), +} +impl From for RangeOp { + fn from(node: Dotdot) -> RangeOp { + RangeOp::Dotdot(node) + } +} +impl From for RangeOp { + fn from(node: Dotdoteq) -> RangeOp { + RangeOp::Dotdoteq(node) + } +} +impl std::fmt::Display for RangeOp { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} +impl AstToken for RangeOp { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + DOTDOT | DOTDOTEQ => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + let res = match syntax.kind() { + DOTDOT => RangeOp::Dotdot(Dotdot { syntax }), + DOTDOTEQ => RangeOp::Dotdoteq(Dotdoteq { syntax }), + _ => return None, + }; + Some(res) + } + fn syntax(&self) -> &SyntaxToken { + match self { + RangeOp::Dotdot(it) => &it.syntax, + RangeOp::Dotdoteq(it) => &it.syntax, + } + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum LiteralToken { + IntNumber(IntNumber), + FloatNumber(FloatNumber), + String(String), + RawString(RawString), + TrueKw(TrueKw), + FalseKw(FalseKw), + ByteString(ByteString), + RawByteString(RawByteString), + Char(Char), + Byte(Byte), +} +impl From for LiteralToken { + fn from(node: IntNumber) -> LiteralToken { + LiteralToken::IntNumber(node) + } +} +impl From for LiteralToken { + fn from(node: FloatNumber) -> LiteralToken { + LiteralToken::FloatNumber(node) + } +} +impl From for LiteralToken { + fn from(node: String) -> LiteralToken { + LiteralToken::String(node) + } +} +impl From for LiteralToken { + fn from(node: RawString) -> LiteralToken { + LiteralToken::RawString(node) + } +} +impl From for LiteralToken { + fn from(node: TrueKw) -> LiteralToken { + LiteralToken::TrueKw(node) + } +} +impl From for LiteralToken { + fn from(node: FalseKw) -> LiteralToken { + LiteralToken::FalseKw(node) + } +} +impl From for LiteralToken { + fn from(node: ByteString) -> LiteralToken { + LiteralToken::ByteString(node) + } +} +impl From for LiteralToken { + fn from(node: RawByteString) -> LiteralToken { + LiteralToken::RawByteString(node) + } +} +impl From for LiteralToken { + fn from(node: Char) -> LiteralToken { + LiteralToken::Char(node) + } +} +impl From for LiteralToken { + fn from(node: Byte) -> LiteralToken { + LiteralToken::Byte(node) + } +} +impl std::fmt::Display for LiteralToken { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} +impl AstToken for LiteralToken { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + INT_NUMBER | FLOAT_NUMBER | STRING | RAW_STRING | TRUE_KW | FALSE_KW | BYTE_STRING + | RAW_BYTE_STRING | CHAR | BYTE => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + let res = match syntax.kind() { + INT_NUMBER => LiteralToken::IntNumber(IntNumber { syntax }), + FLOAT_NUMBER => LiteralToken::FloatNumber(FloatNumber { syntax }), + STRING => LiteralToken::String(String { syntax }), + RAW_STRING => LiteralToken::RawString(RawString { syntax }), + TRUE_KW => LiteralToken::TrueKw(TrueKw { syntax }), + FALSE_KW => LiteralToken::FalseKw(FalseKw { syntax }), + BYTE_STRING => LiteralToken::ByteString(ByteString { syntax }), + RAW_BYTE_STRING => LiteralToken::RawByteString(RawByteString { syntax }), + CHAR => LiteralToken::Char(Char { syntax }), + BYTE => LiteralToken::Byte(Byte { syntax }), + _ => return None, + }; + Some(res) + } + fn syntax(&self) -> &SyntaxToken { + match self { + LiteralToken::IntNumber(it) => &it.syntax, + LiteralToken::FloatNumber(it) => &it.syntax, + LiteralToken::String(it) => &it.syntax, + LiteralToken::RawString(it) => &it.syntax, + LiteralToken::TrueKw(it) => &it.syntax, + LiteralToken::FalseKw(it) => &it.syntax, + LiteralToken::ByteString(it) => &it.syntax, + LiteralToken::RawByteString(it) => &it.syntax, + LiteralToken::Char(it) => &it.syntax, + LiteralToken::Byte(it) => &it.syntax, + } + } +} +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub enum NameRefToken { + Ident(Ident), + IntNumber(IntNumber), +} +impl From for NameRefToken { + fn from(node: Ident) -> NameRefToken { + NameRefToken::Ident(node) + } +} +impl From for NameRefToken { + fn from(node: IntNumber) -> NameRefToken { + NameRefToken::IntNumber(node) + } +} +impl std::fmt::Display for NameRefToken { + fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { + std::fmt::Display::fmt(self.syntax(), f) + } +} +impl AstToken for NameRefToken { + fn can_cast(kind: SyntaxKind) -> bool { + match kind { + IDENT | INT_NUMBER => true, + _ => false, + } + } + fn cast(syntax: SyntaxToken) -> Option { + let res = match syntax.kind() { + IDENT => NameRefToken::Ident(Ident { syntax }), + INT_NUMBER => NameRefToken::IntNumber(IntNumber { syntax }), + _ => return None, + }; + Some(res) + } + fn syntax(&self) -> &SyntaxToken { + match self { + NameRefToken::Ident(it) => &it.syntax, + NameRefToken::IntNumber(it) => &it.syntax, + } + } +} -- cgit v1.2.3