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/tokens.rs | 651 +++++++++++++++++++++++++++ 1 file changed, 651 insertions(+) (limited to 'crates/ra_syntax/src/ast/generated/tokens.rs') 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