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

Convert more tokens

Browse source
This commit is contained in:
Aleksey Kladov 2020-04-10 10:35:39 +02:00
parent 548f562dda
commit 779f06ed77
5 changed files with 34 additions and 268 deletions
Download patch file Download diff file Expand all files Collapse all files

28
crates/ra_syntax/src/ast/generated/nodes.rs
View file

@ -276,7 +276,7 @@ impl ast::DocCommentsOwner for EnumVariant {}
impl ast::AttrsOwner for EnumVariant {}
impl EnumVariant {
pub fn field_def_list(&self) -> Option<FieldDefList> { support::child(&self.syntax) }
pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
pub fn eq_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![=]) }
pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -377,7 +377,7 @@ impl ConstDef {
support::token2(&self.syntax, T![default])
}
pub fn const_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![const]) }
pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
pub fn eq_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![=]) }
pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![;]) }
}
@ -405,7 +405,7 @@ impl ast::TypeAscriptionOwner for StaticDef {}
impl StaticDef {
pub fn static_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![static]) }
pub fn mut_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![mut]) }
pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
pub fn eq_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![=]) }
pub fn body(&self) -> Option<Expr> { support::child(&self.syntax) }
pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![;]) }
}
@ -435,7 +435,7 @@ impl TypeAliasDef {
support::token2(&self.syntax, T![default])
}
pub fn type_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![type]) }
pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
pub fn eq_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![=]) }
pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![;]) }
}
@ -1278,9 +1278,7 @@ impl AstNode for BinExpr {
fn syntax(&self) -> &SyntaxNode { &self.syntax }
}
impl ast::AttrsOwner for BinExpr {}
impl BinExpr {
pub fn bin_op_token(&self) -> Option<BinOp> { support::token(&self.syntax) }
}
impl BinExpr {}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Literal {
pub(crate) syntax: SyntaxNode,
@ -1881,7 +1879,7 @@ impl Attr {
pub fn excl_token(&self) -> Option<Excl> { support::token(&self.syntax) }
pub fn l_brack_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T!['[']) }
pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
pub fn eq_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![=]) }
pub fn input(&self) -> Option<AttrInput> { support::child(&self.syntax) }
pub fn r_brack_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![']']) }
}
@ -1943,7 +1941,7 @@ impl ast::NameOwner for TypeParam {}
impl ast::AttrsOwner for TypeParam {}
impl ast::TypeBoundsOwner for TypeParam {}
impl TypeParam {
pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
pub fn eq_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![=]) }
pub fn default_type(&self) -> Option<TypeRef> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -1965,7 +1963,7 @@ impl ast::NameOwner for ConstParam {}
impl ast::AttrsOwner for ConstParam {}
impl ast::TypeAscriptionOwner for ConstParam {}
impl ConstParam {
pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
pub fn eq_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![=]) }
pub fn default_val(&self) -> Option<Expr> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -2122,7 +2120,7 @@ impl ast::TypeAscriptionOwner for LetStmt {}
impl LetStmt {
pub fn let_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![let]) }
pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
pub fn eq_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![=]) }
pub fn initializer(&self) -> Option<Expr> { support::child(&self.syntax) }
pub fn semicolon_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![;]) }
}
@ -2144,7 +2142,7 @@ impl AstNode for Condition {
impl Condition {
pub fn let_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![let]) }
pub fn pat(&self) -> Option<Pat> { support::child(&self.syntax) }
pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
pub fn eq_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![=]) }
pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -2463,7 +2461,7 @@ impl AstNode for AssocTypeArg {
impl ast::TypeBoundsOwner for AssocTypeArg {}
impl AssocTypeArg {
pub fn name_ref(&self) -> Option<NameRef> { support::child(&self.syntax) }
pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
pub fn eq_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![=]) }
pub fn type_ref(&self) -> Option<TypeRef> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -2501,7 +2499,7 @@ impl AstNode for ConstArg {
}
impl ConstArg {
pub fn literal(&self) -> Option<Literal> { support::child(&self.syntax) }
pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
pub fn eq_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![=]) }
pub fn block_expr(&self) -> Option<BlockExpr> { support::child(&self.syntax) }
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
@ -2597,7 +2595,7 @@ impl AstNode for MetaItem {
}
impl MetaItem {
pub fn path(&self) -> Option<Path> { support::child(&self.syntax) }
pub fn eq_token(&self) -> Option<Eq> { support::token(&self.syntax) }
pub fn eq_token(&self) -> Option<SyntaxToken> { support::token2(&self.syntax, T![=]) }
pub fn attr_input(&self) -> Option<AttrInput> { support::child(&self.syntax) }
pub fn nested_meta_items(&self) -> AstChildren<MetaItem> { support::children(&self.syntax) }
}

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

@ -1410,208 +1410,6 @@ impl AstToken for RangeSeparator {
}
}
#[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<Pipepipe> for BinOp {
fn from(node: Pipepipe) -> BinOp { BinOp::Pipepipe(node) }
}
impl From<Ampamp> for BinOp {
fn from(node: Ampamp) -> BinOp { BinOp::Ampamp(node) }
}
impl From<Eqeq> for BinOp {
fn from(node: Eqeq) -> BinOp { BinOp::Eqeq(node) }
}
impl From<Neq> for BinOp {
fn from(node: Neq) -> BinOp { BinOp::Neq(node) }
}
impl From<Lteq> for BinOp {
fn from(node: Lteq) -> BinOp { BinOp::Lteq(node) }
}
impl From<Gteq> for BinOp {
fn from(node: Gteq) -> BinOp { BinOp::Gteq(node) }
}
impl From<LAngle> for BinOp {
fn from(node: LAngle) -> BinOp { BinOp::LAngle(node) }
}
impl From<RAngle> for BinOp {
fn from(node: RAngle) -> BinOp { BinOp::RAngle(node) }
}
impl From<Plus> for BinOp {
fn from(node: Plus) -> BinOp { BinOp::Plus(node) }
}
impl From<Star> for BinOp {
fn from(node: Star) -> BinOp { BinOp::Star(node) }
}
impl From<Minus> for BinOp {
fn from(node: Minus) -> BinOp { BinOp::Minus(node) }
}
impl From<Slash> for BinOp {
fn from(node: Slash) -> BinOp { BinOp::Slash(node) }
}
impl From<Percent> for BinOp {
fn from(node: Percent) -> BinOp { BinOp::Percent(node) }
}
impl From<Shl> for BinOp {
fn from(node: Shl) -> BinOp { BinOp::Shl(node) }
}
impl From<Shr> for BinOp {
fn from(node: Shr) -> BinOp { BinOp::Shr(node) }
}
impl From<Caret> for BinOp {
fn from(node: Caret) -> BinOp { BinOp::Caret(node) }
}
impl From<Pipe> for BinOp {
fn from(node: Pipe) -> BinOp { BinOp::Pipe(node) }
}
impl From<Amp> for BinOp {
fn from(node: Amp) -> BinOp { BinOp::Amp(node) }
}
impl From<Eq> for BinOp {
fn from(node: Eq) -> BinOp { BinOp::Eq(node) }
}
impl From<Pluseq> for BinOp {
fn from(node: Pluseq) -> BinOp { BinOp::Pluseq(node) }
}
impl From<Slasheq> for BinOp {
fn from(node: Slasheq) -> BinOp { BinOp::Slasheq(node) }
}
impl From<Stareq> for BinOp {
fn from(node: Stareq) -> BinOp { BinOp::Stareq(node) }
}
impl From<Percenteq> for BinOp {
fn from(node: Percenteq) -> BinOp { BinOp::Percenteq(node) }
}
impl From<Shreq> for BinOp {
fn from(node: Shreq) -> BinOp { BinOp::Shreq(node) }
}
impl From<Shleq> for BinOp {
fn from(node: Shleq) -> BinOp { BinOp::Shleq(node) }
}
impl From<Minuseq> for BinOp {
fn from(node: Minuseq) -> BinOp { BinOp::Minuseq(node) }
}
impl From<Pipeeq> for BinOp {
fn from(node: Pipeeq) -> BinOp { BinOp::Pipeeq(node) }
}
impl From<Ampeq> for BinOp {
fn from(node: Ampeq) -> BinOp { BinOp::Ampeq(node) }
}
impl From<Careteq> 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<Self> {
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),