1 files changed, 20 insertions, 64 deletions
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::LogicOp(_) | BinaryOp::CmpOp(_) => Ty::simple(TypeCtor::Bool),
-        | BinaryOp::BooleanAnd
+        BinaryOp::Assignment { .. } => Ty::unit(),
-        | BinaryOp::EqualityTest
+        BinaryOp::ArithOp(_) => match rhs_ty {
-        | 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 {
            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::LogicOp(..) => Ty::simple(TypeCtor::Bool),
-        BinaryOp::Assignment | BinaryOp::EqualityTest => match lhs_ty {
+        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::CmpOp(_) | BinaryOp::Assignment { op: Some(_) } | BinaryOp::ArithOp(_) => {
-        | BinaryOp::GreaterEqualTest
+            match lhs_ty {
-        | BinaryOp::LesserTest
+                Ty::Apply(ApplicationTy { ctor, .. }) => match ctor {
-        | BinaryOp::GreaterTest
+                    TypeCtor::Int(..) | TypeCtor::Float(..) => lhs_ty,
-        | BinaryOp::AddAssign
+                    _ => Ty::Unknown,
-        | BinaryOp::SubAssign
+                },
-        | BinaryOp::DivAssign
+                Ty::Infer(InferTy::IntVar(..)) | Ty::Infer(InferTy::FloatVar(..)) => lhs_ty,
-        | 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,
                _ => Ty::Unknown,
-            },
+            }
-            Ty::Infer(InferTy::IntVar(..)) | Ty::Infer(InferTy::FloatVar(..)) => lhs_ty,
+        }
-            _ => Ty::Unknown,
-        },
-        _ => Ty::Unknown,
    }
 }

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 @@
1	use super::{InferTy, Ty, TypeCtor};	1	use super::{InferTy, Ty, TypeCtor};
2	use crate::{expr::BinaryOp, ty::ApplicationTy};	2	use crate::{
		3	expr::{BinaryOp, CmpOp},
		4	ty::ApplicationTy,
		5	};
3		6
4	pub(super) fn binary_op_return_ty(op: BinaryOp, rhs_ty: Ty) -> Ty {	7	pub(super) fn binary_op_return_ty(op: BinaryOp, rhs_ty: Ty) -> Ty {
5	match op {	8	match op {
6	BinaryOp::BooleanOr	9	BinaryOp::LogicOp(_) \| BinaryOp::CmpOp(_) => Ty::simple(TypeCtor::Bool),
7	\| BinaryOp::BooleanAnd	10	BinaryOp::Assignment { .. } => Ty::unit(),
8	\| BinaryOp::EqualityTest	11	BinaryOp::ArithOp(_) => match rhs_ty {
9	\| BinaryOp::NegatedEqualityTest
10	\| BinaryOp::LesserEqualTest
11	\| BinaryOp::GreaterEqualTest
12	\| BinaryOp::LesserTest
13	\| BinaryOp::GreaterTest => Ty::simple(TypeCtor::Bool),
14	BinaryOp::Assignment
15	\| BinaryOp::AddAssign
16	\| BinaryOp::SubAssign
17	\| BinaryOp::DivAssign
18	\| BinaryOp::MulAssign
19	\| BinaryOp::RemAssign
20	\| BinaryOp::ShrAssign
21	\| BinaryOp::ShlAssign
22	\| BinaryOp::BitAndAssign
23	\| BinaryOp::BitOrAssign
24	\| BinaryOp::BitXorAssign => Ty::unit(),
25	BinaryOp::Addition
26	\| BinaryOp::Subtraction
27	\| BinaryOp::Multiplication
28	\| BinaryOp::Division
29	\| BinaryOp::Remainder
30	\| BinaryOp::LeftShift
31	\| BinaryOp::RightShift
32	\| BinaryOp::BitwiseAnd
33	\| BinaryOp::BitwiseOr
34	\| BinaryOp::BitwiseXor => match rhs_ty {
35	Ty::Apply(ApplicationTy { ctor, .. }) => match ctor {	12	Ty::Apply(ApplicationTy { ctor, .. }) => match ctor {
36	TypeCtor::Int(..) \| TypeCtor::Float(..) => rhs_ty,	13	TypeCtor::Int(..) \| TypeCtor::Float(..) => rhs_ty,
37	_ => Ty::Unknown,	14	_ => Ty::Unknown,
@@ -39,14 +16,15 @@ pub(super) fn binary_op_return_ty(op: BinaryOp, rhs_ty: Ty) -> Ty {
39	Ty::Infer(InferTy::IntVar(..)) \| Ty::Infer(InferTy::FloatVar(..)) => rhs_ty,	16	Ty::Infer(InferTy::IntVar(..)) \| Ty::Infer(InferTy::FloatVar(..)) => rhs_ty,
40	_ => Ty::Unknown,	17	_ => Ty::Unknown,
41	},	18	},
42	BinaryOp::RangeRightOpen \| BinaryOp::RangeRightClosed => Ty::Unknown,
43	}	19	}
44	}	20	}
45		21
46	pub(super) fn binary_op_rhs_expectation(op: BinaryOp, lhs_ty: Ty) -> Ty {	22	pub(super) fn binary_op_rhs_expectation(op: BinaryOp, lhs_ty: Ty) -> Ty {
47	match op {	23	match op {
48	BinaryOp::BooleanAnd \| BinaryOp::BooleanOr => Ty::simple(TypeCtor::Bool),	24	BinaryOp::LogicOp(..) => Ty::simple(TypeCtor::Bool),
49	BinaryOp::Assignment \| BinaryOp::EqualityTest => match lhs_ty {	25	BinaryOp::Assignment { op: None }
		26	\| BinaryOp::CmpOp(CmpOp::Equal)
		27	\| BinaryOp::CmpOp(CmpOp::NotEqual) => match lhs_ty {
50	Ty::Apply(ApplicationTy { ctor, .. }) => match ctor {	28	Ty::Apply(ApplicationTy { ctor, .. }) => match ctor {
51	TypeCtor::Int(..)	29	TypeCtor::Int(..)
52	\| TypeCtor::Float(..)	30	\| TypeCtor::Float(..)
@@ -58,37 +36,15 @@ pub(super) fn binary_op_rhs_expectation(op: BinaryOp, lhs_ty: Ty) -> Ty {
58	Ty::Infer(InferTy::IntVar(..)) \| Ty::Infer(InferTy::FloatVar(..)) => lhs_ty,	36	Ty::Infer(InferTy::IntVar(..)) \| Ty::Infer(InferTy::FloatVar(..)) => lhs_ty,
59	_ => Ty::Unknown,	37	_ => Ty::Unknown,
60	},	38	},
61	BinaryOp::LesserEqualTest	39	BinaryOp::CmpOp(_) \| BinaryOp::Assignment { op: Some(_) } \| BinaryOp::ArithOp(_) => {
62	\| BinaryOp::GreaterEqualTest	40	match lhs_ty {
63	\| BinaryOp::LesserTest	41	Ty::Apply(ApplicationTy { ctor, .. }) => match ctor {
64	\| BinaryOp::GreaterTest	42	TypeCtor::Int(..) \| TypeCtor::Float(..) => lhs_ty,
65	\| BinaryOp::AddAssign	43	_ => Ty::Unknown,
66	\| BinaryOp::SubAssign	44	},
67	\| BinaryOp::DivAssign	45	Ty::Infer(InferTy::IntVar(..)) \| Ty::Infer(InferTy::FloatVar(..)) => lhs_ty,
68	\| BinaryOp::MulAssign
69	\| BinaryOp::RemAssign
70	\| BinaryOp::ShrAssign
71	\| BinaryOp::ShlAssign
72	\| BinaryOp::BitAndAssign
73	\| BinaryOp::BitOrAssign
74	\| BinaryOp::BitXorAssign
75	\| BinaryOp::Addition
76	\| BinaryOp::Subtraction
77	\| BinaryOp::Multiplication
78	\| BinaryOp::Division
79	\| BinaryOp::Remainder
80	\| BinaryOp::LeftShift
81	\| BinaryOp::RightShift
82	\| BinaryOp::BitwiseAnd
83	\| BinaryOp::BitwiseOr
84	\| BinaryOp::BitwiseXor => match lhs_ty {
85	Ty::Apply(ApplicationTy { ctor, .. }) => match ctor {
86	TypeCtor::Int(..) \| TypeCtor::Float(..) => lhs_ty,
87	_ => Ty::Unknown,	46	_ => Ty::Unknown,
88	},	47	}
89	Ty::Infer(InferTy::IntVar(..)) \| Ty::Infer(InferTy::FloatVar(..)) => lhs_ty,	48	}
90	_ => Ty::Unknown,
91	},
92	_ => Ty::Unknown,
93	}	49	}
94	}	50	}