aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--crates/ra_hir/src/ty.rs87
-rw-r--r--crates/ra_hir/src/ty/tests.rs13
-rw-r--r--crates/ra_hir/src/ty/tests/data/binary_op.txt46
-rw-r--r--crates/ra_hir/src/ty/tests/data/boolean_op.txt31
-rw-r--r--crates/ra_syntax/src/ast.rs70
-rw-r--r--crates/ra_syntax/src/grammar.ron1
-rw-r--r--crates/ra_syntax/src/syntax_kinds/generated.rs2
7 files changed, 200 insertions, 50 deletions
diff --git a/crates/ra_hir/src/ty.rs b/crates/ra_hir/src/ty.rs
index bba8527b7..7827e82c4 100644
--- a/crates/ra_hir/src/ty.rs
+++ b/crates/ra_hir/src/ty.rs
@@ -527,9 +527,7 @@ struct InferenceContext<'a, D: HirDatabase> {
527 return_ty: Ty, 527 return_ty: Ty,
528} 528}
529 529
530// helper function that determines whether a binary operator 530fn binary_op_return_ty(op: BinaryOp, rhs_ty: Ty) -> Ty {
531// always returns a boolean
532fn is_boolean_operator(op: BinaryOp) -> bool {
533 match op { 531 match op {
534 BinaryOp::BooleanOr 532 BinaryOp::BooleanOr
535 | BinaryOp::BooleanAnd 533 | BinaryOp::BooleanAnd
@@ -537,7 +535,70 @@ fn is_boolean_operator(op: BinaryOp) -> bool {
537 | BinaryOp::LesserEqualTest 535 | BinaryOp::LesserEqualTest
538 | BinaryOp::GreaterEqualTest 536 | BinaryOp::GreaterEqualTest
539 | BinaryOp::LesserTest 537 | BinaryOp::LesserTest
540 | BinaryOp::GreaterTest => true, 538 | BinaryOp::GreaterTest => Ty::Bool,
539 BinaryOp::Assignment
540 | BinaryOp::AddAssign
541 | BinaryOp::SubAssign
542 | BinaryOp::DivAssign
543 | BinaryOp::MulAssign
544 | BinaryOp::RemAssign
545 | BinaryOp::ShrAssign
546 | BinaryOp::ShlAssign
547 | BinaryOp::BitAndAssign
548 | BinaryOp::BitOrAssign
549 | BinaryOp::BitXorAssign => Ty::unit(),
550 BinaryOp::Addition
551 | BinaryOp::Subtraction
552 | BinaryOp::Multiplication
553 | BinaryOp::Division
554 | BinaryOp::Remainder
555 | BinaryOp::LeftShift
556 | BinaryOp::RightShift
557 | BinaryOp::BitwiseAnd
558 | BinaryOp::BitwiseOr
559 | BinaryOp::BitwiseXor => match rhs_ty {
560 Ty::Uint(..) | Ty::Int(..) | Ty::Float(..) => rhs_ty,
561 _ => Ty::Unknown,
562 },
563 BinaryOp::RangeRightOpen | BinaryOp::RangeRightClosed => Ty::Unknown,
564 }
565}
566
567fn binary_op_rhs_expectation(op: BinaryOp, lhs_ty: Ty) -> Ty {
568 match op {
569 BinaryOp::BooleanAnd | BinaryOp::BooleanOr => Ty::Bool,
570 BinaryOp::Assignment | BinaryOp::EqualityTest => match lhs_ty {
571 Ty::Uint(..) | Ty::Int(..) | Ty::Float(..) | Ty::Str | Ty::Char | Ty::Bool => lhs_ty,
572 _ => Ty::Unknown,
573 },
574 BinaryOp::LesserEqualTest
575 | BinaryOp::GreaterEqualTest
576 | BinaryOp::LesserTest
577 | BinaryOp::GreaterTest
578 | BinaryOp::AddAssign
579 | BinaryOp::SubAssign
580 | BinaryOp::DivAssign
581 | BinaryOp::MulAssign
582 | BinaryOp::RemAssign
583 | BinaryOp::ShrAssign
584 | BinaryOp::ShlAssign
585 | BinaryOp::BitAndAssign
586 | BinaryOp::BitOrAssign
587 | BinaryOp::BitXorAssign
588 | BinaryOp::Addition
589 | BinaryOp::Subtraction
590 | BinaryOp::Multiplication
591 | BinaryOp::Division
592 | BinaryOp::Remainder
593 | BinaryOp::LeftShift
594 | BinaryOp::RightShift
595 | BinaryOp::BitwiseAnd
596 | BinaryOp::BitwiseOr
597 | BinaryOp::BitwiseXor => match lhs_ty {
598 Ty::Uint(..) | Ty::Int(..) | Ty::Float(..) => lhs_ty,
599 _ => Ty::Unknown,
600 },
601 _ => Ty::Unknown,
541 } 602 }
542} 603}
543 604
@@ -889,20 +950,20 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
889 } 950 }
890 Expr::BinaryOp { lhs, rhs, op } => match op { 951 Expr::BinaryOp { lhs, rhs, op } => match op {
891 Some(op) => { 952 Some(op) => {
892 let subtype_expectation = match op { 953 let lhs_expectation = match op {
893 BinaryOp::BooleanAnd | BinaryOp::BooleanOr => { 954 BinaryOp::BooleanAnd | BinaryOp::BooleanOr => {
894 Expectation::has_type(Ty::Bool) 955 Expectation::has_type(Ty::Bool)
895 } 956 }
896 _ => Expectation::none(), 957 _ => Expectation::none(),
897 }; 958 };
898 let _lhs_ty = self.infer_expr(*lhs, &subtype_expectation)?; 959 let lhs_ty = self.infer_expr(*lhs, &lhs_expectation)?;
899 let _rhs_ty = self.infer_expr(*rhs, &subtype_expectation)?; 960 // TODO: find implementation of trait corresponding to operation
900 961 // symbol and resolve associated `Output` type
901 if is_boolean_operator(*op) { 962 let rhs_expectation = binary_op_rhs_expectation(*op, lhs_ty);
902 Ty::Bool 963 let rhs_ty = self.infer_expr(*rhs, &Expectation::has_type(rhs_expectation))?;
903 } else { 964
904 Ty::Unknown 965 // TODO: similar as above, return ty is often associated trait type
905 } 966 binary_op_return_ty(*op, rhs_ty)
906 } 967 }
907 _ => Ty::Unknown, 968 _ => Ty::Unknown,
908 }, 969 },
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index e6c7e225b..2749d740c 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -157,7 +157,7 @@ impl S {
157} 157}
158 158
159#[test] 159#[test]
160fn infer_boolean_op() { 160fn infer_binary_op() {
161 check_inference( 161 check_inference(
162 r#" 162 r#"
163fn f(x: bool) -> i32 { 163fn f(x: bool) -> i32 {
@@ -168,15 +168,18 @@ fn test() {
168 let x = a && b; 168 let x = a && b;
169 let y = true || false; 169 let y = true || false;
170 let z = x == y; 170 let z = x == y;
171 let h = CONST_1 <= CONST_2; 171 let minus_forty: isize = -40isize;
172 let h = minus_forty <= CONST_2;
172 let c = f(z || y) + 5; 173 let c = f(z || y) + 5;
173 let d = b; 174 let d = b;
174 let e = 3i32 && "hello world"; 175 let g = minus_forty ^= i;
176 let ten: usize = 10;
177 let ten_is_eleven = ten == some_num;
175 178
176 10 < 3 179 ten < 3
177} 180}
178"#, 181"#,
179 "boolean_op.txt", 182 "binary_op.txt",
180 ); 183 );
181} 184}
182 185
diff --git a/crates/ra_hir/src/ty/tests/data/binary_op.txt b/crates/ra_hir/src/ty/tests/data/binary_op.txt
new file mode 100644
index 000000000..59c07ff43
--- /dev/null
+++ b/crates/ra_hir/src/ty/tests/data/binary_op.txt
@@ -0,0 +1,46 @@
1[6; 7) 'x': [unknown]
2[22; 34) '{ 0i32 }': i32
3[28; 32) '0i32': i32
4[46; 342) '{ ... < 3 }': bool
5[56; 57) 'x': bool
6[60; 61) 'a': bool
7[60; 66) 'a && b': bool
8[65; 66) 'b': bool
9[76; 77) 'y': bool
10[80; 84) 'true': bool
11[80; 93) 'true || false': bool
12[88; 93) 'false': bool
13[103; 104) 'z': bool
14[107; 108) 'x': bool
15[107; 113) 'x == y': bool
16[112; 113) 'y': bool
17[123; 134) 'minus_forty': isize
18[144; 152) '-40isize': isize
19[145; 152) '40isize': [unknown]
20[162; 163) 'h': bool
21[166; 177) 'minus_forty': isize
22[166; 188) 'minus_...ONST_2': bool
23[181; 188) 'CONST_2': isize
24[198; 199) 'c': i32
25[202; 203) 'f': fn([unknown],) -> i32
26[202; 211) 'f(z || y)': i32
27[202; 215) 'f(z || y) + 5': i32
28[204; 205) 'z': bool
29[204; 210) 'z || y': bool
30[209; 210) 'y': bool
31[214; 215) '5': i32
32[225; 226) 'd': [unknown]
33[229; 230) 'b': [unknown]
34[240; 241) 'g': ()
35[244; 255) 'minus_forty': isize
36[244; 260) 'minus_...y ^= i': ()
37[259; 260) 'i': isize
38[270; 273) 'ten': usize
39[283; 285) '10': usize
40[295; 308) 'ten_is_eleven': bool
41[311; 314) 'ten': usize
42[311; 326) 'ten == some_num': bool
43[318; 326) 'some_num': usize
44[333; 336) 'ten': usize
45[333; 340) 'ten < 3': bool
46[339; 340) '3': usize
diff --git a/crates/ra_hir/src/ty/tests/data/boolean_op.txt b/crates/ra_hir/src/ty/tests/data/boolean_op.txt
deleted file mode 100644
index cce8d68fb..000000000
--- a/crates/ra_hir/src/ty/tests/data/boolean_op.txt
+++ /dev/null
@@ -1,31 +0,0 @@
1[6; 7) 'x': [unknown]
2[22; 34) '{ 0i32 }': i32
3[28; 32) '0i32': i32
4[46; 237) '{ ... < 3 }': bool
5[56; 57) 'x': bool
6[60; 61) 'a': bool
7[60; 66) 'a && b': bool
8[65; 66) 'b': bool
9[76; 77) 'y': bool
10[80; 84) 'true': bool
11[80; 93) 'true || false': bool
12[88; 93) 'false': bool
13[103; 104) 'z': bool
14[107; 108) 'x': bool
15[107; 113) 'x == y': bool
16[112; 113) 'y': bool
17[123; 124) 'h': bool
18[127; 134) 'CONST_1': [unknown]
19[127; 145) 'CONST_...ONST_2': bool
20[138; 145) 'CONST_2': [unknown]
21[155; 156) 'c': [unknown]
22[159; 172) 'f(z || y) + 5': [unknown]
23[182; 183) 'd': [unknown]
24[186; 187) 'b': [unknown]
25[197; 198) 'e': bool
26[201; 205) '3i32': bool
27[201; 222) '3i32 &...world"': bool
28[209; 222) '"hello world"': bool
29[229; 231) '10': [unknown]
30[229; 235) '10 < 3': bool
31[234; 235) '3': [unknown]
diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index 9df8ec663..9ab59738f 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -504,7 +504,52 @@ pub enum BinOp {
504 LesserTest, 504 LesserTest,
505 /// The `>` operator for comparison 505 /// The `>` operator for comparison
506 GreaterTest, 506 GreaterTest,
507 // TODO: lots of others 507 /// The `+` operator for addition
508 Addition,
509 /// The `*` operator for multiplication
510 Multiplication,
511 /// The `-` operator for subtraction
512 Subtraction,
513 /// The `/` operator for division
514 Division,
515 /// The `%` operator for remainder after division
516 Remainder,
517 /// The `<<` operator for left shift
518 LeftShift,
519 /// The `>>` operator for right shift
520 RightShift,
521 /// The `^` operator for bitwise XOR
522 BitwiseXor,
523 /// The `|` operator for bitwise OR
524 BitwiseOr,
525 /// The `&` operator for bitwise AND
526 BitwiseAnd,
527 /// The `..` operator for right-open ranges
528 RangeRightOpen,
529 /// The `..=` operator for right-closed ranges
530 RangeRightClosed,
531 /// The `=` operator for assignment
532 Assignment,
533 /// The `+=` operator for assignment after additon
534 AddAssign,
535 /// The `/=` operator for assignment after division
536 DivAssign,
537 /// The `*=` operator for assignment after multiplication
538 MulAssign,
539 /// The `%=` operator for assignment after remainders
540 RemAssign,
541 /// The `>>=` operator for assignment after shifting right
542 ShrAssign,
543 /// The `<<=` operator for assignment after shifting left
544 ShlAssign,
545 /// The `-=` operator for assignment after subtraction
546 SubAssign,
547 /// The `|=` operator for assignment after bitwise OR
548 BitOrAssign,
549 /// The `&=` operator for assignment after bitwise AND
550 BitAndAssign,
551 /// The `^=` operator for assignment after bitwise XOR
552 BitXorAssign,
508} 553}
509 554
510impl<'a> BinExpr<'a> { 555impl<'a> BinExpr<'a> {
@@ -519,6 +564,29 @@ impl<'a> BinExpr<'a> {
519 GTEQ => Some(BinOp::GreaterEqualTest), 564 GTEQ => Some(BinOp::GreaterEqualTest),
520 L_ANGLE => Some(BinOp::LesserTest), 565 L_ANGLE => Some(BinOp::LesserTest),
521 R_ANGLE => Some(BinOp::GreaterTest), 566 R_ANGLE => Some(BinOp::GreaterTest),
567 PLUS => Some(BinOp::Addition),
568 STAR => Some(BinOp::Multiplication),
569 MINUS => Some(BinOp::Subtraction),
570 SLASH => Some(BinOp::Division),
571 PERCENT => Some(BinOp::Remainder),
572 SHL => Some(BinOp::LeftShift),
573 SHR => Some(BinOp::RightShift),
574 CARET => Some(BinOp::BitwiseXor),
575 PIPE => Some(BinOp::BitwiseOr),
576 AMP => Some(BinOp::BitwiseAnd),
577 DOTDOT => Some(BinOp::RangeRightOpen),
578 DOTDOTEQ => Some(BinOp::RangeRightClosed),
579 EQ => Some(BinOp::Assignment),
580 PLUSEQ => Some(BinOp::AddAssign),
581 SLASHEQ => Some(BinOp::DivAssign),
582 STAREQ => Some(BinOp::MulAssign),
583 PERCENTEQ => Some(BinOp::RemAssign),
584 SHREQ => Some(BinOp::ShrAssign),
585 SHLEQ => Some(BinOp::ShlAssign),
586 MINUSEQ => Some(BinOp::SubAssign),
587 PIPEEQ => Some(BinOp::BitOrAssign),
588 AMPEQ => Some(BinOp::BitAndAssign),
589 CARETEQ => Some(BinOp::BitXorAssign),
522 _ => None, 590 _ => None,
523 }) 591 })
524 .next() 592 .next()
diff --git a/crates/ra_syntax/src/grammar.ron b/crates/ra_syntax/src/grammar.ron
index 3c640ed47..d7505ea06 100644
--- a/crates/ra_syntax/src/grammar.ron
+++ b/crates/ra_syntax/src/grammar.ron
@@ -49,6 +49,7 @@ Grammar(
49 ["^=", "CARETEQ"], 49 ["^=", "CARETEQ"],
50 ["/=", "SLASHEQ"], 50 ["/=", "SLASHEQ"],
51 ["*=", "STAREQ"], 51 ["*=", "STAREQ"],
52 ["%=", "PERCENTEQ"],
52 ["&&", "AMPAMP"], 53 ["&&", "AMPAMP"],
53 ["||", "PIPEPIPE"], 54 ["||", "PIPEPIPE"],
54 ["<<", "SHL"], 55 ["<<", "SHL"],
diff --git a/crates/ra_syntax/src/syntax_kinds/generated.rs b/crates/ra_syntax/src/syntax_kinds/generated.rs
index ef4588d93..830fac9f4 100644
--- a/crates/ra_syntax/src/syntax_kinds/generated.rs
+++ b/crates/ra_syntax/src/syntax_kinds/generated.rs
@@ -58,6 +58,7 @@ pub enum SyntaxKind {
58 CARETEQ, 58 CARETEQ,
59 SLASHEQ, 59 SLASHEQ,
60 STAREQ, 60 STAREQ,
61 PERCENTEQ,
61 AMPAMP, 62 AMPAMP,
62 PIPEPIPE, 63 PIPEPIPE,
63 SHL, 64 SHL,
@@ -319,6 +320,7 @@ impl SyntaxKind {
319 CARETEQ => &SyntaxInfo { name: "CARETEQ" }, 320 CARETEQ => &SyntaxInfo { name: "CARETEQ" },
320 SLASHEQ => &SyntaxInfo { name: "SLASHEQ" }, 321 SLASHEQ => &SyntaxInfo { name: "SLASHEQ" },
321 STAREQ => &SyntaxInfo { name: "STAREQ" }, 322 STAREQ => &SyntaxInfo { name: "STAREQ" },
323 PERCENTEQ => &SyntaxInfo { name: "PERCENTEQ" },
322 AMPAMP => &SyntaxInfo { name: "AMPAMP" }, 324 AMPAMP => &SyntaxInfo { name: "AMPAMP" },
323 PIPEPIPE => &SyntaxInfo { name: "PIPEPIPE" }, 325 PIPEPIPE => &SyntaxInfo { name: "PIPEPIPE" },
324 SHL => &SyntaxInfo { name: "SHL" }, 326 SHL => &SyntaxInfo { name: "SHL" },