Infer range types

3 files changed, 76 insertions, 4 deletions

diff --git a/crates/ra_hir_def/src/body/lower.rs b/crates/ra_hir_def/src/body/lower.rs
index 331736cb2..d18964d54 100644
--- a/crates/ra_hir_def/src/body/lower.rs
+++ b/crates/ra_hir_def/src/body/lower.rs
@@ -8,7 +8,7 @@ use hir_expand::{
 use ra_arena::Arena;
 use ra_syntax::{
     ast::{
-        self, ArgListOwner, ArrayExprKind, LiteralKind, LoopBodyOwner, NameOwner,
+        self, ArgListOwner, ArrayExprKind, LiteralKind, LoopBodyOwner, NameOwner, RangeOp,
         TypeAscriptionOwner,
     },
     AstNode, AstPtr,
@@ -429,10 +429,28 @@ where
                 let index = self.collect_expr_opt(e.index());
                 self.alloc_expr(Expr::Index { base, index }, syntax_ptr)
             }
+            ast::Expr::RangeExpr(e) => {
+                let lhs = e.start().map(|lhs| self.collect_expr(lhs));
+                let rhs = e.end().map(|rhs| self.collect_expr(rhs));
+                match (lhs, e.op_kind(), rhs) {
+                    (None, _, None) => self.alloc_expr(Expr::RangeFull, syntax_ptr),
+                    (Some(lhs), _, None) => self.alloc_expr(Expr::RangeFrom { lhs }, syntax_ptr),
+                    (None, Some(RangeOp::Inclusive), Some(rhs)) => {
+                        self.alloc_expr(Expr::RangeToInclusive { rhs }, syntax_ptr)
+                    }
+                    (Some(lhs), Some(RangeOp::Inclusive), Some(rhs)) => {
+                        self.alloc_expr(Expr::RangeInclusive { lhs, rhs }, syntax_ptr)
+                    }
+                    // If RangeOp is missing, fallback to exclusive range.
+                    (None, _, Some(rhs)) => self.alloc_expr(Expr::RangeTo { rhs }, syntax_ptr),
+                    (Some(lhs), _, Some(rhs)) => {
+                        self.alloc_expr(Expr::Range { lhs, rhs }, syntax_ptr)
+                    }
+                }
+            }
 
             // FIXME implement HIR for these:
             ast::Expr::Label(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
-            ast::Expr::RangeExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
             ast::Expr::MacroCall(e) => match self.expander.enter_expand(self.db, e) {
                 Some((mark, expansion)) => {
                     let id = self.collect_expr(expansion);
diff --git a/crates/ra_hir_def/src/expr.rs b/crates/ra_hir_def/src/expr.rs
index 04c1d8f69..115090218 100644
--- a/crates/ra_hir_def/src/expr.rs
+++ b/crates/ra_hir_def/src/expr.rs
@@ -130,6 +130,24 @@ pub enum Expr {
         rhs: ExprId,
         op: Option<BinaryOp>,
     },
+    RangeFull,
+    RangeFrom {
+        lhs: ExprId,
+    },
+    RangeTo {
+        rhs: ExprId,
+    },
+    Range {
+        lhs: ExprId,
+        rhs: ExprId,
+    },
+    RangeToInclusive {
+        rhs: ExprId,
+    },
+    RangeInclusive {
+        lhs: ExprId,
+        rhs: ExprId,
+    },
     Index {
         base: ExprId,
         index: ExprId,
@@ -284,7 +302,9 @@ impl Expr {
             Expr::Lambda { body, .. } => {
                 f(*body);
             }
-            Expr::BinaryOp { lhs, rhs, .. } => {
+            Expr::BinaryOp { lhs, rhs, .. }
+            | Expr::Range { lhs, rhs }
+            | Expr::RangeInclusive { lhs, rhs } => {
                 f(*lhs);
                 f(*rhs);
             }
@@ -292,7 +312,11 @@ impl Expr {
                 f(*base);
                 f(*index);
             }
-            Expr::Field { expr, .. }
+            Expr::RangeFull => {}
+            Expr::RangeFrom { lhs: expr }
+            | Expr::RangeTo { rhs: expr }
+            | Expr::RangeToInclusive { rhs: expr }
+            | Expr::Field { expr, .. }
             | Expr::Await { expr }
             | Expr::Try { expr }
             | Expr::Cast { expr, .. }
diff --git a/crates/ra_hir_def/src/path.rs b/crates/ra_hir_def/src/path.rs
index 10688df4d..ff252fe44 100644
--- a/crates/ra_hir_def/src/path.rs
+++ b/crates/ra_hir_def/src/path.rs
@@ -409,6 +409,36 @@ pub mod known {
         Path::from_simple_segments(PathKind::Abs, vec![name::STD, name::OPS, name::TRY_TYPE])
     }
 
+    pub fn std_ops_range() -> Path {
+        Path::from_simple_segments(PathKind::Abs, vec![name::STD, name::OPS, name::RANGE_TYPE])
+    }
+
+    pub fn std_ops_range_from() -> Path {
+        Path::from_simple_segments(PathKind::Abs, vec![name::STD, name::OPS, name::RANGE_FROM_TYPE])
+    }
+
+    pub fn std_ops_range_full() -> Path {
+        Path::from_simple_segments(PathKind::Abs, vec![name::STD, name::OPS, name::RANGE_FULL_TYPE])
+    }
+
+    pub fn std_ops_range_inclusive() -> Path {
+        Path::from_simple_segments(
+            PathKind::Abs,
+            vec![name::STD, name::OPS, name::RANGE_INCLUSIVE_TYPE],
+        )
+    }
+
+    pub fn std_ops_range_to() -> Path {
+        Path::from_simple_segments(PathKind::Abs, vec![name::STD, name::OPS, name::RANGE_TO_TYPE])
+    }
+
+    pub fn std_ops_range_to_inclusive() -> Path {
+        Path::from_simple_segments(
+            PathKind::Abs,
+            vec![name::STD, name::OPS, name::RANGE_TO_INCLUSIVE_TYPE],
+        )
+    }
+
     pub fn std_result_result() -> Path {
         Path::from_simple_segments(PathKind::Abs, vec![name::STD, name::RESULT, name::RESULT_TYPE])
     }