Merge #440

440: Implement type inference for boolean operators r=flodiebold a=marcusklaas

Tried implementing the easiest part of https://github.com/rust-analyzer/rust-analyzer/issues/390. Hope this is somewhat close to what the intent of the issue was. Found it surprisingly easy to find my way around the repository - it's well organized!

Very grateful for any pointers.

Co-authored-by: Marcus Klaas de Vries <[email protected]>

1 files changed, 52 insertions, 0 deletions

diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index c10169d90..9df8ec663 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -489,6 +489,58 @@ impl<'a> PrefixExpr<'a> {
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub enum BinOp {
+    /// The `||` operator for boolean OR
+    BooleanOr,
+    /// The `&&` operator for boolean AND
+    BooleanAnd,
+    /// The `==` operator for equality testing
+    EqualityTest,
+    /// The `<=` operator for lesser-equal testing
+    LesserEqualTest,
+    /// The `>=` operator for greater-equal testing
+    GreaterEqualTest,
+    /// The `<` operator for comparison
+    LesserTest,
+    /// The `>` operator for comparison
+    GreaterTest,
+    // TODO: lots of others
+}
+
+impl<'a> BinExpr<'a> {
+    pub fn op(&self) -> Option<BinOp> {
+        self.syntax()
+            .children()
+            .filter_map(|c| match c.kind() {
+                PIPEPIPE => Some(BinOp::BooleanOr),
+                AMPAMP => Some(BinOp::BooleanAnd),
+                EQEQ => Some(BinOp::EqualityTest),
+                LTEQ => Some(BinOp::LesserEqualTest),
+                GTEQ => Some(BinOp::GreaterEqualTest),
+                L_ANGLE => Some(BinOp::LesserTest),
+                R_ANGLE => Some(BinOp::GreaterTest),
+                _ => None,
+            })
+            .next()
+    }
+
+    pub fn lhs(self) -> Option<Expr<'a>> {
+        children(self).nth(0)
+    }
+
+    pub fn rhs(self) -> Option<Expr<'a>> {
+        children(self).nth(1)
+    }
+
+    pub fn sub_exprs(self) -> (Option<Expr<'a>>, Option<Expr<'a>>) {
+        let mut children = children(self);
+        let first = children.next();
+        let second = children.next();
+        (first, second)
+    }
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 pub enum SelfParamFlavor {
     /// self
     Owned,