internal: merge hir::BinaryOp and ast::BinOp

matklad · matklad · commit 90357a9090a8 · 2021-08-14T18:10:01.000+03:00
diff --git a/crates/hir_def/src/body/lower.rs b/crates/hir_def/src/body/lower.rs
@@ -27,8 +27,8 @@ use crate::{
     builtin_type::{BuiltinFloat, BuiltinInt, BuiltinUint},
     db::DefDatabase,
     expr::{
-        dummy_expr_id, Array, BinaryOp, BindingAnnotation, Expr, ExprId, Label, LabelId, Literal,
-        MatchArm, MatchGuard, Pat, PatId, RecordFieldPat, RecordLitField, Statement,
+        dummy_expr_id, Array, BindingAnnotation, Expr, ExprId, Label, LabelId, Literal, MatchArm,
+        MatchGuard, Pat, PatId, RecordFieldPat, RecordLitField, Statement,
     },
     intern::Interned,
     item_scope::BuiltinShadowMode,
@@ -508,7 +508,7 @@ impl ExprCollector<'_> {
             ast::Expr::BinExpr(e) => {
                 let lhs = self.collect_expr_opt(e.lhs());
                 let rhs = self.collect_expr_opt(e.rhs());
-                let op = e.op_kind().map(BinaryOp::from);
+                let op = e.op_kind();
                 self.alloc_expr(Expr::BinaryOp { lhs, rhs, op }, syntax_ptr)
             }
             ast::Expr::TupleExpr(e) => {
diff --git a/crates/ide_assists/src/handlers/apply_demorgan.rs b/crates/ide_assists/src/handlers/apply_demorgan.rs
@@ -26,7 +26,13 @@ pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext) -> Option<(
     let expr = ctx.find_node_at_offset::<ast::BinExpr>()?;
     let op = expr.op_kind()?;
     let op_range = expr.op_token()?.text_range();
-    let opposite_op = opposite_logic_op(op)?;
+
+    let opposite_op = match op {
+        ast::BinaryOp::LogicOp(ast::LogicOp::And) => "||",
+        ast::BinaryOp::LogicOp(ast::LogicOp::Or) => "&&",
+        _ => return None,
+    };
+
     let cursor_in_range = op_range.contains_range(ctx.frange.range);
     if !cursor_in_range {
         return None;
@@ -136,15 +142,6 @@ pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext) -> Option<(
     )
 }
 
-// Return the opposite text for a given logical operator, if it makes sense
-fn opposite_logic_op(kind: ast::BinOp) -> Option<&'static str> {
-    match kind {
-        ast::BinOp::BooleanOr => Some("&&"),
-        ast::BinOp::BooleanAnd => Some("||"),
-        _ => None,
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use crate::tests::{check_assist, check_assist_not_applicable};
diff --git a/crates/ide_assists/src/handlers/extract_function.rs b/crates/ide_assists/src/handlers/extract_function.rs
@@ -892,7 +892,7 @@ fn expr_require_exclusive_access(ctx: &AssistContext, expr: &ast::Expr) -> Optio
     let parent = expr.syntax().parent()?;
 
     if let Some(bin_expr) = ast::BinExpr::cast(parent.clone()) {
-        if bin_expr.op_kind()?.is_assignment() {
+        if matches!(bin_expr.op_kind()?, ast::BinaryOp::Assignment { .. }) {
             return Some(bin_expr.lhs()?.syntax() == expr.syntax());
         }
         return Some(false);
diff --git a/crates/ide_assists/src/handlers/flip_binexpr.rs b/crates/ide_assists/src/handlers/flip_binexpr.rs
@@ -1,4 +1,4 @@
-use syntax::ast::{AstNode, BinExpr, BinOp};
+use syntax::ast::{self, AstNode, BinExpr};
 
 use crate::{AssistContext, AssistId, AssistKind, Assists};
 
@@ -56,14 +56,19 @@ enum FlipAction {
     DontFlip,
 }
 
-impl From<BinOp> for FlipAction {
-    fn from(op_kind: BinOp) -> Self {
+impl From<ast::BinaryOp> for FlipAction {
+    fn from(op_kind: ast::BinaryOp) -> Self {
         match op_kind {
-            kind if kind.is_assignment() => FlipAction::DontFlip,
-            BinOp::GreaterTest => FlipAction::FlipAndReplaceOp("<"),
-            BinOp::GreaterEqualTest => FlipAction::FlipAndReplaceOp("<="),
-            BinOp::LesserTest => FlipAction::FlipAndReplaceOp(">"),
-            BinOp::LesserEqualTest => FlipAction::FlipAndReplaceOp(">="),
+            ast::BinaryOp::Assignment { .. } => FlipAction::DontFlip,
+            ast::BinaryOp::CmpOp(ast::CmpOp::Ord { ordering, strict }) => {
+                let rev_op = match (ordering, strict) {
+                    (ast::Ordering::Less, true) => ">",
+                    (ast::Ordering::Less, false) => ">=",
+                    (ast::Ordering::Greater, true) => "<",
+                    (ast::Ordering::Greater, false) => "<=",
+                };
+                FlipAction::FlipAndReplaceOp(rev_op)
+            }
             _ => FlipAction::Flip,
         }
     }
diff --git a/crates/ide_assists/src/handlers/pull_assignment_up.rs b/crates/ide_assists/src/handlers/pull_assignment_up.rs
@@ -39,7 +39,7 @@ pub(crate) fn pull_assignment_up(acc: &mut Assists, ctx: &AssistContext) -> Opti
     let assign_expr = ctx.find_node_at_offset::<ast::BinExpr>()?;
 
     let op_kind = assign_expr.op_kind()?;
-    if op_kind != ast::BinOp::Assignment {
+    if op_kind != (ast::BinaryOp::Assignment { op: None }) {
         cov_mark::hit!(test_cant_pull_non_assignments);
         return None;
     }
@@ -143,7 +143,7 @@ impl<'a> AssignmentsCollector<'a> {
     }
 
     fn collect_expr(&mut self, expr: &ast::BinExpr) -> Option<()> {
-        if expr.op_kind()? == ast::BinOp::Assignment
+        if expr.op_kind()? == (ast::BinaryOp::Assignment { op: None })
             && is_equivalent(self.sema, &expr.lhs()?, &self.common_lhs)
         {
             self.assignments.push((expr.clone(), expr.rhs()?));
diff --git a/crates/ide_assists/src/utils.rs b/crates/ide_assists/src/utils.rs
@@ -210,12 +210,17 @@ pub(crate) fn invert_boolean_expression(expr: ast::Expr) -> ast::Expr {
 fn invert_special_case(expr: &ast::Expr) -> Option<ast::Expr> {
     match expr {
         ast::Expr::BinExpr(bin) => match bin.op_kind()? {
-            ast::BinOp::NegatedEqualityTest => bin.replace_op(T![==]).map(|it| it.into()),
-            ast::BinOp::EqualityTest => bin.replace_op(T![!=]).map(|it| it.into()),
-            ast::BinOp::LesserTest => bin.replace_op(T![>=]).map(|it| it.into()),
-            ast::BinOp::LesserEqualTest => bin.replace_op(T![>]).map(|it| it.into()),
-            ast::BinOp::GreaterTest => bin.replace_op(T![<=]).map(|it| it.into()),
-            ast::BinOp::GreaterEqualTest => bin.replace_op(T![<]).map(|it| it.into()),
+            ast::BinaryOp::CmpOp(op) => {
+                let rev_op = match op {
+                    ast::CmpOp::Eq { negated: false } => T![!=],
+                    ast::CmpOp::Eq { negated: true } => T![==],
+                    ast::CmpOp::Ord { ordering: ast::Ordering::Less, strict: true } => T![>=],
+                    ast::CmpOp::Ord { ordering: ast::Ordering::Less, strict: false } => T![>],
+                    ast::CmpOp::Ord { ordering: ast::Ordering::Greater, strict: true } => T![<=],
+                    ast::CmpOp::Ord { ordering: ast::Ordering::Greater, strict: false } => T![<],
+                };
+                bin.replace_op(rev_op).map(ast::Expr::from)
+            }
             // Parenthesize other expressions before prefixing `!`
             _ => Some(make::expr_prefix(T![!], make::expr_paren(expr.clone()))),
         },
diff --git a/crates/ide_assists/src/utils/gen_trait_fn_body.rs b/crates/ide_assists/src/utils/gen_trait_fn_body.rs
@@ -1,7 +1,7 @@
 //! This module contains functions to generate default trait impl function bodies where possible.
 
 use syntax::{
-    ast::{self, edit::AstNodeEdit, make, AstNode, NameOwner},
+    ast::{self, edit::AstNodeEdit, make, AstNode, BinaryOp, CmpOp, LogicOp, NameOwner},
     ted,
 };
 
@@ -325,7 +325,7 @@ fn gen_hash_impl(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
 fn gen_partial_eq(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
     fn gen_eq_chain(expr: Option<ast::Expr>, cmp: ast::Expr) -> Option<ast::Expr> {
         match expr {
-            Some(expr) => Some(make::expr_op(ast::BinOp::BooleanAnd, expr, cmp)),
+            Some(expr) => Some(make::expr_bin_op(expr, BinaryOp::LogicOp(LogicOp::And), cmp)),
             None => Some(cmp),
         }
     }
@@ -362,7 +362,8 @@ fn gen_partial_eq(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
             let lhs = make::expr_call(make_discriminant()?, make::arg_list(Some(lhs_name.clone())));
             let rhs_name = make::expr_path(make::ext::ident_path("other"));
             let rhs = make::expr_call(make_discriminant()?, make::arg_list(Some(rhs_name.clone())));
-            let eq_check = make::expr_op(ast::BinOp::EqualityTest, lhs, rhs);
+            let eq_check =
+                make::expr_bin_op(lhs, BinaryOp::CmpOp(CmpOp::Eq { negated: false }), rhs);
 
             let mut case_count = 0;
             let mut arms = vec![];
@@ -386,7 +387,11 @@ fn gen_partial_eq(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
 
                             let lhs = make::expr_path(make::ext::ident_path(l_name));
                             let rhs = make::expr_path(make::ext::ident_path(r_name));
-                            let cmp = make::expr_op(ast::BinOp::EqualityTest, lhs, rhs);
+                            let cmp = make::expr_bin_op(
+                                lhs,
+                                BinaryOp::CmpOp(CmpOp::Eq { negated: false }),
+                                rhs,
+                            );
                             expr = gen_eq_chain(expr, cmp);
                         }
 
@@ -415,7 +420,11 @@ fn gen_partial_eq(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
 
                             let lhs = make::expr_path(make::ext::ident_path(&l_name));
                             let rhs = make::expr_path(make::ext::ident_path(&r_name));
-                            let cmp = make::expr_op(ast::BinOp::EqualityTest, lhs, rhs);
+                            let cmp = make::expr_bin_op(
+                                lhs,
+                                BinaryOp::CmpOp(CmpOp::Eq { negated: false }),
+                                rhs,
+                            );
                             expr = gen_eq_chain(expr, cmp);
                         }
 
@@ -455,7 +464,8 @@ fn gen_partial_eq(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
                     let lhs = make::expr_field(lhs, &field.name()?.to_string());
                     let rhs = make::expr_path(make::ext::ident_path("other"));
                     let rhs = make::expr_field(rhs, &field.name()?.to_string());
-                    let cmp = make::expr_op(ast::BinOp::EqualityTest, lhs, rhs);
+                    let cmp =
+                        make::expr_bin_op(lhs, BinaryOp::CmpOp(CmpOp::Eq { negated: false }), rhs);
                     expr = gen_eq_chain(expr, cmp);
                 }
                 make::block_expr(None, expr).indent(ast::edit::IndentLevel(1))
@@ -469,7 +479,8 @@ fn gen_partial_eq(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
                     let lhs = make::expr_field(lhs, &idx);
                     let rhs = make::expr_path(make::ext::ident_path("other"));
                     let rhs = make::expr_field(rhs, &idx);
-                    let cmp = make::expr_op(ast::BinOp::EqualityTest, lhs, rhs);
+                    let cmp =
+                        make::expr_bin_op(lhs, BinaryOp::CmpOp(CmpOp::Eq { negated: false }), rhs);
                     expr = gen_eq_chain(expr, cmp);
                 }
                 make::block_expr(None, expr).indent(ast::edit::IndentLevel(1))
diff --git a/crates/ide_db/src/search.rs b/crates/ide_db/src/search.rs
@@ -655,7 +655,7 @@ fn reference_access(def: &Definition, name_ref: &ast::NameRef) -> Option<Referen
         match_ast! {
             match (node) {
                 ast::BinExpr(expr) => {
-                    if expr.op_kind()?.is_assignment() {
+                    if matches!(expr.op_kind()?, ast::BinaryOp::Assignment { .. }) {
                         // If the variable or field ends on the LHS's end then it's a Write (covers fields and locals).
                         // FIXME: This is not terribly accurate.
                         if let Some(lhs) = expr.lhs() {
diff --git a/crates/syntax/src/ast.rs b/crates/syntax/src/ast.rs
@@ -18,13 +18,13 @@ use crate::{
 };
 
 pub use self::{
-    expr_ext::{ArrayExprKind, BinOp, Effect, ElseBranch, LiteralKind},
+    expr_ext::{ArrayExprKind, Effect, ElseBranch, LiteralKind},
     generated::{nodes::*, tokens::*},
     node_ext::{
         AttrKind, AttrsOwnerNode, FieldKind, Macro, NameLike, NameOrNameRef, PathSegmentKind,
         SelfParamKind, SlicePatComponents, StructKind, TypeBoundKind, VisibilityKind,
     },
-    operators::{ArithOp, BinaryOp, CmpOp, LogicOp, RangeOp, UnaryOp, Ordering},
+    operators::{ArithOp, BinaryOp, CmpOp, LogicOp, Ordering, RangeOp, UnaryOp},
     token_ext::{
         CommentKind, CommentPlacement, CommentShape, FormatSpecifier, HasFormatSpecifier, IsString,
         QuoteOffsets, Radix,
diff --git a/crates/syntax/src/ast/expr_ext.rs b/crates/syntax/src/ast/expr_ext.rs
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
diff --git a/crates/syntax/src/ast/operators.rs b/crates/syntax/src/ast/operators.rs

Original file line number	Diff line number	Diff line change
`@@ -892,7 +892,7 @@ fn expr_require_exclusive_access(ctx: &AssistContext, expr: &ast::Expr) -> Optio`
`892`	`892`	`let parent = expr.syntax().parent()?;`
`893`	`893`
`894`	`894`	`if let Some(bin_expr) = ast::BinExpr::cast(parent.clone()) {`
`895`		`- if bin_expr.op_kind()?.is_assignment() {`
	`895`	`+ if matches!(bin_expr.op_kind()?, ast::BinaryOp::Assignment { .. }) {`
`896`	`896`	`return Some(bin_expr.lhs()?.syntax() == expr.syntax());`
`897`	`897`	`}`
`898`	`898`	`return Some(false);`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ pub(crate) fn pull_assignment_up(acc: &mut Assists, ctx: &AssistContext) -> Opti`
`39`	`39`	`let assign_expr = ctx.find_node_at_offset::<ast::BinExpr>()?;`
`40`	`40`
`41`	`41`	`let op_kind = assign_expr.op_kind()?;`
`42`		`- if op_kind != ast::BinOp::Assignment {`
	`42`	`+ if op_kind != (ast::BinaryOp::Assignment { op: None }) {`
`43`	`43`	`cov_mark::hit!(test_cant_pull_non_assignments);`
`44`	`44`	`return None;`
`45`	`45`	`}`
`@@ -143,7 +143,7 @@ impl<'a> AssignmentsCollector<'a> {`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`fn collect_expr(&mut self, expr: &ast::BinExpr) -> Option<()> {`
`146`		`- if expr.op_kind()? == ast::BinOp::Assignment`
	`146`	`+ if expr.op_kind()? == (ast::BinaryOp::Assignment { op: None })`
`147`	`147`	`&& is_equivalent(self.sema, &expr.lhs()?, &self.common_lhs)`
`148`	`148`	`{`
`149`	`149`	`self.assignments.push((expr.clone(), expr.rhs()?));`