Scale token generation back

1 files changed, 0 insertions, 239 deletions

diff --git a/crates/ra_syntax/src/ast/generated/tokens.rs b/crates/ra_syntax/src/ast/generated/tokens.rs
index 7611ce4cb..293f91c2e 100644
--- a/crates/ra_syntax/src/ast/generated/tokens.rs
+++ b/crates/ra_syntax/src/ast/generated/tokens.rs
@@ -1365,242 +1365,3 @@ impl AstToken for RDollar {
     }
     fn syntax(&self) -> &SyntaxToken { &self.syntax }
 }
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub enum RangeSeparator {
-    Dotdot(Dotdot),
-    Dotdotdot(Dotdotdot),
-    Dotdoteq(Dotdoteq),
-}
-impl From<Dotdot> for RangeSeparator {
-    fn from(node: Dotdot) -> RangeSeparator { RangeSeparator::Dotdot(node) }
-}
-impl From<Dotdotdot> for RangeSeparator {
-    fn from(node: Dotdotdot) -> RangeSeparator { RangeSeparator::Dotdotdot(node) }
-}
-impl From<Dotdoteq> 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<Self> {
-        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 PrefixOp {
-    Minus(Minus),
-    Excl(Excl),
-    Star(Star),
-}
-impl From<Minus> for PrefixOp {
-    fn from(node: Minus) -> PrefixOp { PrefixOp::Minus(node) }
-}
-impl From<Excl> for PrefixOp {
-    fn from(node: Excl) -> PrefixOp { PrefixOp::Excl(node) }
-}
-impl From<Star> 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<Self> {
-        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<Dotdot> for RangeOp {
-    fn from(node: Dotdot) -> RangeOp { RangeOp::Dotdot(node) }
-}
-impl From<Dotdoteq> 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<Self> {
-        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),
-    ByteString(ByteString),
-    RawByteString(RawByteString),
-    Char(Char),
-    Byte(Byte),
-}
-impl From<IntNumber> for LiteralToken {
-    fn from(node: IntNumber) -> LiteralToken { LiteralToken::IntNumber(node) }
-}
-impl From<FloatNumber> for LiteralToken {
-    fn from(node: FloatNumber) -> LiteralToken { LiteralToken::FloatNumber(node) }
-}
-impl From<String> for LiteralToken {
-    fn from(node: String) -> LiteralToken { LiteralToken::String(node) }
-}
-impl From<RawString> for LiteralToken {
-    fn from(node: RawString) -> LiteralToken { LiteralToken::RawString(node) }
-}
-impl From<ByteString> for LiteralToken {
-    fn from(node: ByteString) -> LiteralToken { LiteralToken::ByteString(node) }
-}
-impl From<RawByteString> for LiteralToken {
-    fn from(node: RawByteString) -> LiteralToken { LiteralToken::RawByteString(node) }
-}
-impl From<Char> for LiteralToken {
-    fn from(node: Char) -> LiteralToken { LiteralToken::Char(node) }
-}
-impl From<Byte> 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 | BYTE_STRING | RAW_BYTE_STRING
-            | CHAR | BYTE => true,
-            _ => false,
-        }
-    }
-    fn cast(syntax: SyntaxToken) -> Option<Self> {
-        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 }),
-            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::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<Ident> for NameRefToken {
-    fn from(node: Ident) -> NameRefToken { NameRefToken::Ident(node) }
-}
-impl From<IntNumber> 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<Self> {
-        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,
-        }
-    }
-}