Introduce separate hir::BinaryOp

Unlike ast::BinOp, it has significantly more structure to it, so it's
easier to, say, handle all assignment-like operations in the same way.

2 files changed, 21 insertions, 67 deletions

diff --git a/crates/ra_hir/src/ty/infer.rs b/crates/ra_hir/src/ty/infer.rs
index 675df4a22..33bfd0952 100644
--- a/crates/ra_hir/src/ty/infer.rs
+++ b/crates/ra_hir/src/ty/infer.rs
@@ -1265,9 +1265,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
             Expr::BinaryOp { lhs, rhs, op } => match op {
                 Some(op) => {
                     let lhs_expectation = match op {
-                        BinaryOp::BooleanAnd | BinaryOp::BooleanOr => {
-                            Expectation::has_type(Ty::simple(TypeCtor::Bool))
-                        }
+                        BinaryOp::LogicOp(..) => Expectation::has_type(Ty::simple(TypeCtor::Bool)),
                         _ => Expectation::none(),
                     };
                     let lhs_ty = self.infer_expr(*lhs, &lhs_expectation);
diff --git a/crates/ra_hir/src/ty/op.rs b/crates/ra_hir/src/ty/op.rs
index 9ba868298..1d089f1b0 100644
--- a/crates/ra_hir/src/ty/op.rs
+++ b/crates/ra_hir/src/ty/op.rs
@@ -1,37 +1,14 @@
 use super::{InferTy, Ty, TypeCtor};
-use crate::{expr::BinaryOp, ty::ApplicationTy};
+use crate::{
+    expr::{BinaryOp, CmpOp},
+    ty::ApplicationTy,
+};
 
 pub(super) fn binary_op_return_ty(op: BinaryOp, rhs_ty: Ty) -> Ty {
     match op {
-        BinaryOp::BooleanOr
-        | BinaryOp::BooleanAnd
-        | BinaryOp::EqualityTest
-        | BinaryOp::NegatedEqualityTest
-        | BinaryOp::LesserEqualTest
-        | BinaryOp::GreaterEqualTest
-        | BinaryOp::LesserTest
-        | BinaryOp::GreaterTest => Ty::simple(TypeCtor::Bool),
-        BinaryOp::Assignment
-        | BinaryOp::AddAssign
-        | BinaryOp::SubAssign
-        | BinaryOp::DivAssign
-        | BinaryOp::MulAssign
-        | BinaryOp::RemAssign
-        | BinaryOp::ShrAssign
-        | BinaryOp::ShlAssign
-        | BinaryOp::BitAndAssign
-        | BinaryOp::BitOrAssign
-        | BinaryOp::BitXorAssign => Ty::unit(),
-        BinaryOp::Addition
-        | BinaryOp::Subtraction
-        | BinaryOp::Multiplication
-        | BinaryOp::Division
-        | BinaryOp::Remainder
-        | BinaryOp::LeftShift
-        | BinaryOp::RightShift
-        | BinaryOp::BitwiseAnd
-        | BinaryOp::BitwiseOr
-        | BinaryOp::BitwiseXor => match rhs_ty {
+        BinaryOp::LogicOp(_) | BinaryOp::CmpOp(_) => Ty::simple(TypeCtor::Bool),
+        BinaryOp::Assignment { .. } => Ty::unit(),
+        BinaryOp::ArithOp(_) => match rhs_ty {
             Ty::Apply(ApplicationTy { ctor, .. }) => match ctor {
                 TypeCtor::Int(..) | TypeCtor::Float(..) => rhs_ty,
                 _ => Ty::Unknown,
@@ -39,14 +16,15 @@ pub(super) fn binary_op_return_ty(op: BinaryOp, rhs_ty: Ty) -> Ty {
             Ty::Infer(InferTy::IntVar(..)) | Ty::Infer(InferTy::FloatVar(..)) => rhs_ty,
             _ => Ty::Unknown,
         },
-        BinaryOp::RangeRightOpen | BinaryOp::RangeRightClosed => Ty::Unknown,
     }
 }
 
 pub(super) fn binary_op_rhs_expectation(op: BinaryOp, lhs_ty: Ty) -> Ty {
     match op {
-        BinaryOp::BooleanAnd | BinaryOp::BooleanOr => Ty::simple(TypeCtor::Bool),
-        BinaryOp::Assignment | BinaryOp::EqualityTest => match lhs_ty {
+        BinaryOp::LogicOp(..) => Ty::simple(TypeCtor::Bool),
+        BinaryOp::Assignment { op: None }
+        | BinaryOp::CmpOp(CmpOp::Equal)
+        | BinaryOp::CmpOp(CmpOp::NotEqual) => match lhs_ty {
             Ty::Apply(ApplicationTy { ctor, .. }) => match ctor {
                 TypeCtor::Int(..)
                 | TypeCtor::Float(..)
@@ -58,37 +36,15 @@ pub(super) fn binary_op_rhs_expectation(op: BinaryOp, lhs_ty: Ty) -> Ty {
             Ty::Infer(InferTy::IntVar(..)) | Ty::Infer(InferTy::FloatVar(..)) => lhs_ty,
             _ => Ty::Unknown,
         },
-        BinaryOp::LesserEqualTest
-        | BinaryOp::GreaterEqualTest
-        | BinaryOp::LesserTest
-        | BinaryOp::GreaterTest
-        | BinaryOp::AddAssign
-        | BinaryOp::SubAssign
-        | BinaryOp::DivAssign
-        | BinaryOp::MulAssign
-        | BinaryOp::RemAssign
-        | BinaryOp::ShrAssign
-        | BinaryOp::ShlAssign
-        | BinaryOp::BitAndAssign
-        | BinaryOp::BitOrAssign
-        | BinaryOp::BitXorAssign
-        | BinaryOp::Addition
-        | BinaryOp::Subtraction
-        | BinaryOp::Multiplication
-        | BinaryOp::Division
-        | BinaryOp::Remainder
-        | BinaryOp::LeftShift
-        | BinaryOp::RightShift
-        | BinaryOp::BitwiseAnd
-        | BinaryOp::BitwiseOr
-        | BinaryOp::BitwiseXor => match lhs_ty {
-            Ty::Apply(ApplicationTy { ctor, .. }) => match ctor {
-                TypeCtor::Int(..) | TypeCtor::Float(..) => lhs_ty,
+        BinaryOp::CmpOp(_) | BinaryOp::Assignment { op: Some(_) } | BinaryOp::ArithOp(_) => {
+            match lhs_ty {
+                Ty::Apply(ApplicationTy { ctor, .. }) => match ctor {
+                    TypeCtor::Int(..) | TypeCtor::Float(..) => lhs_ty,
+                    _ => Ty::Unknown,
+                },
+                Ty::Infer(InferTy::IntVar(..)) | Ty::Infer(InferTy::FloatVar(..)) => lhs_ty,
                 _ => Ty::Unknown,
-            },
-            Ty::Infer(InferTy::IntVar(..)) | Ty::Infer(InferTy::FloatVar(..)) => lhs_ty,
-            _ => Ty::Unknown,
-        },
-        _ => Ty::Unknown,
+            }
+        }
     }
 }