language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-09-26 20:09:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Fixup tests

Browse source
This commit is contained in:
Marcus Klaas de Vries 2019-01-14 19:30:21 +01:00
parent 606d66a714
commit a9a6a50c75
12 changed files with 284 additions and 212 deletions
Download patch file Download diff file Expand all files Collapse all files

132
crates/ra_syntax/src/ast/generated.rs
View file

@ -664,7 +664,7 @@ pub enum ExprKind<'a> {
PrefixExpr(&'a PrefixExpr),
RangeExpr(&'a RangeExpr),
BinExpr(&'a BinExpr),
LiteralExpr(&'a LiteralExpr),
Literal(&'a Literal),
}
impl AstNode for Expr {
@ -696,7 +696,7 @@ impl AstNode for Expr {
| PREFIX_EXPR
| RANGE_EXPR
| BIN_EXPR
| LITERAL_EXPR => Some(Expr::from_repr(syntax.into_repr())),
| LITERAL => Some(Expr::from_repr(syntax.into_repr())),
_ => None,
}
}
@ -733,7 +733,7 @@ impl Expr {
PREFIX_EXPR => ExprKind::PrefixExpr(PrefixExpr::cast(&self.syntax).unwrap()),
RANGE_EXPR => ExprKind::RangeExpr(RangeExpr::cast(&self.syntax).unwrap()),
BIN_EXPR => ExprKind::BinExpr(BinExpr::cast(&self.syntax).unwrap()),
LITERAL_EXPR => ExprKind::LiteralExpr(LiteralExpr::cast(&self.syntax).unwrap()),
LITERAL => ExprKind::Literal(Literal::cast(&self.syntax).unwrap()),
_ => unreachable!(),
}
}
@ -793,6 +793,31 @@ impl AstNode for ExternCrateItem {
impl ExternCrateItem {}
// FalseKw
#[derive(Debug, PartialEq, Eq, Hash)]
#[repr(transparent)]
pub struct FalseKw {
pub(crate) syntax: SyntaxNode,
}
unsafe impl TransparentNewType for FalseKw {
type Repr = rowan::SyntaxNode<RaTypes>;
}
impl AstNode for FalseKw {
fn cast(syntax: &SyntaxNode) -> Option<&Self> {
match syntax.kind() {
FALSE_KW => Some(FalseKw::from_repr(syntax.into_repr())),
_ => None,
}
}
fn syntax(&self) -> &SyntaxNode { &self.syntax }
fn to_owned(&self) -> TreeArc<FalseKw> { TreeArc::cast(self.syntax.to_owned()) }
}
impl ast::AstToken for FalseKw {}
impl FalseKw {}
// FieldExpr
#[derive(Debug, PartialEq, Eq, Hash)]
#[repr(transparent)]
@ -867,7 +892,7 @@ impl AstNode for FloatNumber {
}
}
fn syntax(&self) -> &SyntaxNode { &self.syntax }
fn to_owned(&self) -> TreePtr<FloatNumber> { TreePtr::cast(self.syntax.to_owned()) }
fn to_owned(&self) -> TreeArc<FloatNumber> { TreeArc::cast(self.syntax.to_owned()) }
}
@ -1173,7 +1198,7 @@ impl AstNode for IntNumber {
}
}
fn syntax(&self) -> &SyntaxNode { &self.syntax }
fn to_owned(&self) -> TreePtr<IntNumber> { TreePtr::cast(self.syntax.to_owned()) }
fn to_owned(&self) -> TreeArc<IntNumber> { TreeArc::cast(self.syntax.to_owned()) }
}
@ -1365,25 +1390,10 @@ unsafe impl TransparentNewType for Literal {
type Repr = rowan::SyntaxNode<RaTypes>;
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LiteralKind<'a> {
String(&'a String),
ByteString(&'a ByteString),
Char(&'a Char),
Byte(&'a Byte),
IntNumber(&'a IntNumber),
FloatNumber(&'a FloatNumber),
}
impl AstNode for Literal {
fn cast(syntax: &SyntaxNode) -> Option<&Self> {
match syntax.kind() {
| STRING
| BYTE_STRING
| CHAR
| BYTE
| INT_NUMBER
| FLOAT_NUMBER => Some(Literal::from_repr(syntax.into_repr())),
LITERAL => Some(Literal::from_repr(syntax.into_repr())),
_ => None,
}
}
@ -1391,22 +1401,13 @@ impl AstNode for Literal {
fn to_owned(&self) -> TreeArc<Literal> { TreeArc::cast(self.syntax.to_owned()) }
}
impl Literal {
pub fn kind(&self) -> LiteralKind {
match self.syntax.kind() {
STRING => LiteralKind::String(String::cast(&self.syntax).unwrap()),
BYTE_STRING => LiteralKind::ByteString(ByteString::cast(&self.syntax).unwrap()),
CHAR => LiteralKind::Char(Char::cast(&self.syntax).unwrap()),
BYTE => LiteralKind::Byte(Byte::cast(&self.syntax).unwrap()),
INT_NUMBER => LiteralKind::IntNumber(IntNumber::cast(&self.syntax).unwrap()),
FLOAT_NUMBER => LiteralKind::FloatNumber(FloatNumber::cast(&self.syntax).unwrap()),
_ => unreachable!(),
}
pub fn literal_expr(&self) -> Option<&LiteralExpr> {
super::child_opt(self)
}
}
impl Literal {}
// LiteralExpr
#[derive(Debug, PartialEq, Eq, Hash)]
#[repr(transparent)]
@ -1417,24 +1418,54 @@ unsafe impl TransparentNewType for LiteralExpr {
type Repr = rowan::SyntaxNode<RaTypes>;
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LiteralExprKind<'a> {
String(&'a String),
ByteString(&'a ByteString),
Char(&'a Char),
Byte(&'a Byte),
IntNumber(&'a IntNumber),
FloatNumber(&'a FloatNumber),
TrueKw(&'a TrueKw),
FalseKw(&'a FalseKw),
}
impl AstNode for LiteralExpr {
fn cast(syntax: &SyntaxNode) -> Option<&Self> {
match syntax.kind() {
LITERAL_EXPR => Some(LiteralExpr::from_repr(syntax.into_repr())),
| STRING
| BYTE_STRING
| CHAR
| BYTE
| INT_NUMBER
| FLOAT_NUMBER
| TRUE_KW
| FALSE_KW => Some(LiteralExpr::from_repr(syntax.into_repr())),
_ => None,
}
}
fn syntax(&self) -> &SyntaxNode { &self.syntax }
fn to_owned(&self) -> TreePtr<LiteralExpr> { TreePtr::cast(self.syntax.to_owned()) }
fn to_owned(&self) -> TreeArc<LiteralExpr> { TreeArc::cast(self.syntax.to_owned()) }
}
impl LiteralExpr {
pub fn literal(&self) -> Option<&Literal> {
super::child_opt(self)
pub fn kind(&self) -> LiteralExprKind {
match self.syntax.kind() {
STRING => LiteralExprKind::String(String::cast(&self.syntax).unwrap()),
BYTE_STRING => LiteralExprKind::ByteString(ByteString::cast(&self.syntax).unwrap()),
CHAR => LiteralExprKind::Char(Char::cast(&self.syntax).unwrap()),
BYTE => LiteralExprKind::Byte(Byte::cast(&self.syntax).unwrap()),
INT_NUMBER => LiteralExprKind::IntNumber(IntNumber::cast(&self.syntax).unwrap()),
FLOAT_NUMBER => LiteralExprKind::FloatNumber(FloatNumber::cast(&self.syntax).unwrap()),
TRUE_KW => LiteralExprKind::TrueKw(TrueKw::cast(&self.syntax).unwrap()),
FALSE_KW => LiteralExprKind::FalseKw(FalseKw::cast(&self.syntax).unwrap()),
_ => unreachable!(),
}
}
}
impl LiteralExpr {}
// LoopExpr
#[derive(Debug, PartialEq, Eq, Hash)]
#[repr(transparent)]
@ -3025,6 +3056,31 @@ impl ast::AttrsOwner for TraitDef {}
impl ast::DocCommentsOwner for TraitDef {}
impl TraitDef {}
// TrueKw
#[derive(Debug, PartialEq, Eq, Hash)]
#[repr(transparent)]
pub struct TrueKw {
pub(crate) syntax: SyntaxNode,
}
unsafe impl TransparentNewType for TrueKw {
type Repr = rowan::SyntaxNode<RaTypes>;
}
impl AstNode for TrueKw {
fn cast(syntax: &SyntaxNode) -> Option<&Self> {
match syntax.kind() {
TRUE_KW => Some(TrueKw::from_repr(syntax.into_repr())),
_ => None,
}
}
fn syntax(&self) -> &SyntaxNode { &self.syntax }
fn to_owned(&self) -> TreeArc<TrueKw> { TreeArc::cast(self.syntax.to_owned()) }
}
impl ast::AstToken for TrueKw {}
impl TrueKw {}
// TryExpr
#[derive(Debug, PartialEq, Eq, Hash)]
#[repr(transparent)]