nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-30 02:33:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Target only the actual operator.

Browse Source 
Renamed `BinExpr::op()` and `PrefixExpr::op()` to `op_kind`.
Now `op()` returns the `SyntaxNode`.
This commit is contained in:
Marco Groppo 2019-03-24 22:21:22 +01:00
parent acac7415a6
commit 67055c47da
3 changed files with 58 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
crates/ra_assists/src/flip_eq_operands.rs
View File

@ -1,24 +1,23 @@
use hir::db::HirDatabase;
use ra_syntax::{
ast::{AstNode, BinExpr, BinOp}
};
use ra_syntax::ast::{AstNode, BinExpr, BinOp};
use crate::{AssistCtx, Assist, AssistId};
pub(crate) fn flip_eq_operands(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
let expr = ctx.node_at_offset::<BinExpr>()?;
let lhs = expr.lhs()?.syntax();
let rhs = expr.rhs()?.syntax();
let op_range = expr.op()?.range();
let cursor_in_range = ctx.frange.range.is_subrange(&op_range);
let allowed_ops = [BinOp::EqualityTest, BinOp::NegatedEqualityTest];
let expr_op = expr.op()?;
if !allowed_ops.iter().any(|o| *o == expr_op) {
let expr_op = expr.op_kind()?;
if !cursor_in_range || !allowed_ops.iter().any(|o| *o == expr_op) {
return None;
}
let node = expr.syntax();
let prev = node.first_child()?;
let next = node.last_child()?;
ctx.add_action(AssistId("flip_eq_operands"), "flip equality operands", |edit| {
edit.target(node.range());
edit.replace(prev.range(), next.text());
edit.replace(next.range(), prev.text());
edit.target(op_range);
edit.replace(lhs.range(), rhs.text());
edit.replace(rhs.range(), lhs.text());
});
ctx.build()
@ -82,6 +81,6 @@ mod tests {
#[test]
fn flip_eq_operands_target() {
check_assist_target(flip_eq_operands, "fn f() { let res = 1 ==<|> 2; }", "1 == 2")
check_assist_target(flip_eq_operands, "fn f() { let res = 1 ==<|> 2; }", "==")
}
}

4
crates/ra_hir/src/expr.rs
View File

@ -680,7 +680,7 @@ impl ExprCollector {
}
ast::ExprKind::PrefixExpr(e) => {
let expr = self.collect_expr_opt(e.expr());
if let Some(op) = e.op() {
if let Some(op) = e.op_kind() {
self.alloc_expr(Expr::UnaryOp { expr, op }, syntax_ptr)
} else {
self.alloc_expr(Expr::Missing, syntax_ptr)
@ -703,7 +703,7 @@ impl ExprCollector {
ast::ExprKind::BinExpr(e) => {
let lhs = self.collect_expr_opt(e.lhs());
let rhs = self.collect_expr_opt(e.rhs());
let op = e.op();
let op = e.op_kind();
self.alloc_expr(Expr::BinaryOp { lhs, rhs, op }, syntax_ptr)
}
ast::ExprKind::TupleExpr(e) => {

78
crates/ra_syntax/src/ast.rs
View File

@ -521,7 +521,7 @@ pub enum PrefixOp {
}
impl PrefixExpr {
pub fn op(&self) -> Option<PrefixOp> {
pub fn op_kind(&self) -> Option<PrefixOp> {
match self.syntax().first_child()?.kind() {
STAR => Some(PrefixOp::Deref),
EXCL => Some(PrefixOp::Not),
@ -529,6 +529,10 @@ impl PrefixExpr {
_ => None,
}
}
pub fn op(&self) -> Option<&SyntaxNode> {
self.syntax().first_child()
}
}
#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
@ -598,46 +602,54 @@ pub enum BinOp {
}
impl BinExpr {
pub fn op(&self) -> Option<BinOp> {
fn op_details(&self) -> Option<(&SyntaxNode, BinOp)> {
self.syntax()
.children()
.filter_map(|c| match c.kind() {
PIPEPIPE => Some(BinOp::BooleanOr),
AMPAMP => Some(BinOp::BooleanAnd),
EQEQ => Some(BinOp::EqualityTest),
NEQ => Some(BinOp::NegatedEqualityTest),
LTEQ => Some(BinOp::LesserEqualTest),
GTEQ => Some(BinOp::GreaterEqualTest),
L_ANGLE => Some(BinOp::LesserTest),
R_ANGLE => Some(BinOp::GreaterTest),
PLUS => Some(BinOp::Addition),
STAR => Some(BinOp::Multiplication),
MINUS => Some(BinOp::Subtraction),
SLASH => Some(BinOp::Division),
PERCENT => Some(BinOp::Remainder),
SHL => Some(BinOp::LeftShift),
SHR => Some(BinOp::RightShift),
CARET => Some(BinOp::BitwiseXor),
PIPE => Some(BinOp::BitwiseOr),
AMP => Some(BinOp::BitwiseAnd),
DOTDOT => Some(BinOp::RangeRightOpen),
DOTDOTEQ => Some(BinOp::RangeRightClosed),
EQ => Some(BinOp::Assignment),
PLUSEQ => Some(BinOp::AddAssign),
SLASHEQ => Some(BinOp::DivAssign),
STAREQ => Some(BinOp::MulAssign),
PERCENTEQ => Some(BinOp::RemAssign),
SHREQ => Some(BinOp::ShrAssign),
SHLEQ => Some(BinOp::ShlAssign),
MINUSEQ => Some(BinOp::SubAssign),
PIPEEQ => Some(BinOp::BitOrAssign),
AMPEQ => Some(BinOp::BitAndAssign),
CARETEQ => Some(BinOp::BitXorAssign),
PIPEPIPE => Some((c, BinOp::BooleanOr)),
AMPAMP => Some((c, BinOp::BooleanAnd)),
EQEQ => Some((c, BinOp::EqualityTest)),
NEQ => Some((c, BinOp::NegatedEqualityTest)),
LTEQ => Some((c, BinOp::LesserEqualTest)),
GTEQ => Some((c, BinOp::GreaterEqualTest)),
L_ANGLE => Some((c, BinOp::LesserTest)),
R_ANGLE => Some((c, BinOp::GreaterTest)),
PLUS => Some((c, BinOp::Addition)),
STAR => Some((c, BinOp::Multiplication)),
MINUS => Some((c, BinOp::Subtraction)),
SLASH => Some((c, BinOp::Division)),
PERCENT => Some((c, BinOp::Remainder)),
SHL => Some((c, BinOp::LeftShift)),
SHR => Some((c, BinOp::RightShift)),
CARET => Some((c, BinOp::BitwiseXor)),
PIPE => Some((c, BinOp::BitwiseOr)),
AMP => Some((c, BinOp::BitwiseAnd)),
DOTDOT => Some((c, BinOp::RangeRightOpen)),
DOTDOTEQ => Some((c, BinOp::RangeRightClosed)),
EQ => Some((c, BinOp::Assignment)),
PLUSEQ => Some((c, BinOp::AddAssign)),
SLASHEQ => Some((c, BinOp::DivAssign)),
STAREQ => Some((c, BinOp::MulAssign)),
PERCENTEQ => Some((c, BinOp::RemAssign)),
SHREQ => Some((c, BinOp::ShrAssign)),
SHLEQ => Some((c, BinOp::ShlAssign)),
MINUSEQ => Some((c, BinOp::SubAssign)),
PIPEEQ => Some((c, BinOp::BitOrAssign)),
AMPEQ => Some((c, BinOp::BitAndAssign)),
CARETEQ => Some((c, BinOp::BitXorAssign)),
_ => None,
})
.next()
}
pub fn op_kind(&self) -> Option<BinOp> {
self.op_details().map(|t| t.1)
}
pub fn op(&self) -> Option<&SyntaxNode> {
self.op_details().map(|t| t.0)
}
pub fn lhs(&self) -> Option<&Expr> {
children(self).nth(0)
}