Infer range patterns correctly

The type of a range pattern is the element's type, not the range type, unlike a range expression.

Author: ChayimFriedman2

crates/hir-ty/src/infer/pat.rs

@@ -11,7 +11,6 @@ use hir_expand::name::Name;
 use rustc_ast_ir::Mutability;
 use rustc_type_ir::inherent::{GenericArg as _, GenericArgs as _, IntoKind, SliceLike, Ty as _};
 use stdx::TupleExt;
-use syntax::ast::RangeOp;
 
 use crate::{
     DeclContext, DeclOrigin, InferenceDiagnostic,
@@ -350,51 +349,16 @@ impl<'db> InferenceContext<'_, 'db> {
                 self.infer_slice_pat(expected, prefix, *slice, suffix, default_bm, decl)
             }
             Pat::Wild => expected,
-            Pat::Range { start, end, range_type } => {
-                // FIXME: Expectation
-                let lhs_expectation = Expectation::none();
-                let lhs_ty =
-                    start.map(|start| self.infer_expr(start, &lhs_expectation, ExprIsRead::Yes));
-                let rhs_expectation = lhs_ty.map_or_else(Expectation::none, Expectation::HasType);
-                let rhs_ty = end.map(|end| self.infer_expr(end, &rhs_expectation, ExprIsRead::Yes));
-                let single_arg_adt = |adt, ty: Ty<'db>| {
-                    Ty::new_adt(
-                        self.interner(),
-                        adt,
-                        GenericArgs::new_from_iter(self.interner(), [ty.into()]),
-                    )
-                };
-                match (range_type, lhs_ty, rhs_ty) {
-                    (RangeOp::Exclusive, None, None) => match self.resolve_range_full() {
-                        Some(adt) => Ty::new_adt(self.interner(), adt, self.types.empty_args),
-                        None => self.err_ty(),
-                    },
-                    (RangeOp::Exclusive, None, Some(ty)) => match self.resolve_range_to() {
-                        Some(adt) => single_arg_adt(adt, ty),
-                        None => self.err_ty(),
-                    },
-                    (RangeOp::Inclusive, None, Some(ty)) => {
-                        match self.resolve_range_to_inclusive() {
-                            Some(adt) => single_arg_adt(adt, ty),
-                            None => self.err_ty(),
-                        }
-                    }
-                    (RangeOp::Exclusive, Some(_), Some(ty)) => match self.resolve_range() {
-                        Some(adt) => single_arg_adt(adt, ty),
-                        None => self.err_ty(),
-                    },
-                    (RangeOp::Inclusive, Some(_), Some(ty)) => {
-                        match self.resolve_range_inclusive() {
-                            Some(adt) => single_arg_adt(adt, ty),
-                            None => self.err_ty(),
-                        }
-                    }
-                    (RangeOp::Exclusive, Some(ty), None) => match self.resolve_range_from() {
-                        Some(adt) => single_arg_adt(adt, ty),
-                        None => self.err_ty(),
-                    },
-                    (RangeOp::Inclusive, _, None) => self.err_ty(),
+            Pat::Range { start, end, range_type: _ } => {
+                if let Some(start) = *start {
+                    let start_ty = self.infer_expr(start, &Expectation::None, ExprIsRead::Yes);
+                    _ = self.demand_eqtype(start.into(), expected, start_ty);
+                }
+                if let Some(end) = *end {
+                    let end_ty = self.infer_expr(end, &Expectation::None, ExprIsRead::Yes);
+                    _ = self.demand_eqtype(end.into(), expected, end_ty);
                 }
+                expected
             }
             &Pat::Lit(expr) => {
                 // Don't emit type mismatches again, the expression lowering already did that.

crates/hir-ty/src/tests/patterns.rs

@@ -1287,3 +1287,45 @@ fn bar() {
     "#,
     );
 }
+
+#[test]
+fn range_pattern() {
+    check_no_mismatches(
+        r#"
+//- minicore: range
+fn main() {
+    let byte: u8 = 0u8;
+    let b = match byte {
+        b'0'..=b'9' => true,
+        _ => false,
+    };
+}
+    "#,
+    );
+    check_infer(
+        r#"
+//- minicore: range
+fn main() {
+    let byte: u8 = 0u8;
+    let b = match byte {
+        b'0'..=b'9' => true,
+        _ => false,
+    };
+}
+    "#,
+        expect![[r#"
+            10..118 '{     ...  }; }': ()
+            20..24 'byte': u8
+            31..34 '0u8': u8
+            44..45 'b': bool
+            48..115 'match ...     }': bool
+            54..58 'byte': u8
+            69..73 'b'0'': u8
+            69..80 'b'0'..=b'9'': u8
+            76..80 'b'9'': u8
+            84..88 'true': bool
+            98..99 '_': u8
+            103..108 'false': bool
+        "#]],
+    );
+}