language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-09-28 04:44:57 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Scale token generation back

Browse source
This commit is contained in:
Aleksey Kladov 2020-04-10 11:49:13 +02:00
parent 779f06ed77
commit 8d71a6bf0c
9 changed files with 136 additions and 547 deletions
Download patch file Download diff file Expand all files Collapse all files

239
crates/ra_syntax/src/ast/generated/tokens.rs
View file

@ -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,
}
}
}