Merge #11481

[rust.git] / crates / hir_ty / src / infer / expr.rs

diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index a892a680d7e4408f42a9e8f456acefdfef8ed8a5..13f64d682521e8733ec67b6fd2edb44990f02736 100644 (file)
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -8,10 +8,7 @@
 
 use chalk_ir::{cast::Cast, fold::Shift, Mutability, TyVariableKind};
 use hir_def::{
-    expr::{
-        ArithOp, Array, BinaryOp, CmpOp, Expr, ExprId, Literal, MatchGuard, Ordering, Statement,
-        UnaryOp,
-    },
+    expr::{ArithOp, Array, BinaryOp, CmpOp, Expr, ExprId, Literal, Ordering, Statement, UnaryOp},
     path::{GenericArg, GenericArgs},
     resolver::resolver_for_expr,
     FieldId, FunctionId, ItemContainerId, Lookup,
@@ -158,6 +155,11 @@ fn infer_expr_inner(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
 
                 coerce.complete()
             }
+            &Expr::Let { pat, expr } => {
+                let input_ty = self.infer_expr(expr, &Expectation::none());
+                self.infer_pat(pat, &input_ty, BindingMode::default());
+                TyKind::Scalar(Scalar::Bool).intern(Interner)
+            }
             Expr::Block { statements, tail, label, id: _ } => {
                 let old_resolver = mem::replace(
                     &mut self.resolver,
@@ -378,20 +380,11 @@ fn infer_expr_inner(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
                 for arm in arms.iter() {
                     self.diverges = Diverges::Maybe;
                     let _pat_ty = self.infer_pat(arm.pat, &input_ty, BindingMode::default());
-                    match arm.guard {
-                        Some(MatchGuard::If { expr: guard_expr }) => {
-                            self.infer_expr(
-                                guard_expr,
-                                &Expectation::has_type(
-                                    TyKind::Scalar(Scalar::Bool).intern(Interner),
-                                ),
-                            );
-                        }
-                        Some(MatchGuard::IfLet { expr, pat }) => {
-                            let input_ty = self.infer_expr(expr, &Expectation::none());
-                            let _pat_ty = self.infer_pat(pat, &input_ty, BindingMode::default());
-                        }
-                        _ => {}
+                    if let Some(guard_expr) = arm.guard {
+                        self.infer_expr(
+                            guard_expr,
+                            &Expectation::has_type(TyKind::Scalar(Scalar::Bool).intern(Interner)),
+                        );
                     }
 
                     let arm_ty = self.infer_expr_inner(arm.expr, &expected);
@@ -799,8 +792,15 @@ fn infer_expr_inner(&mut self, tgt_expr: ExprId, expected: &Expectation) -> Ty {
                             ),
                         );
 
-                        let repeat_expr = &self.body.exprs[repeat];
-                        consteval::eval_usize(repeat_expr)
+                        consteval::eval_usize(
+                            repeat,
+                            consteval::ConstEvalCtx {
+                                exprs: &body.exprs,
+                                pats: &body.pats,
+                                local_data: Default::default(),
+                                infer: &mut |x| self.infer_expr(x, &expected),
+                            },
+                        )
                     }
                 };
 
@@ -989,7 +989,7 @@ fn infer_method_call(
                 self.trait_env.clone(),
                 krate,
                 &traits_in_scope,
-                self.resolver.module(),
+                self.resolver.module().into(),
                 method_name,
             )
         });