From e837df84792d2cbf5c606788c7cab7ea4d1829d0 Mon Sep 17 00:00:00 2001
From: Jonas Schievink <jonasschievink@gmail.com>
Date: Wed, 10 Feb 2021 14:41:54 +0100
Subject: [PATCH] infer: update resolver when descending into block

---
 crates/hir_ty/src/infer/expr.rs   | 36 +++++++++++++++++--------------
 crates/hir_ty/src/tests/simple.rs | 19 ++++++++++++++++
 2 files changed, 39 insertions(+), 16 deletions(-)

diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 12f1591c81..d05c715e72 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -137,24 +137,28 @@ impl<'a> InferenceContext<'a> {
 
                 self.coerce_merge_branch(&then_ty, &else_ty)
             }
-            Expr::Block { statements, tail, label, id: _ } => match label {
-                Some(_) => {
-                    let break_ty = self.table.new_type_var();
-                    self.breakables.push(BreakableContext {
-                        may_break: false,
-                        break_ty: break_ty.clone(),
-                        label: label.map(|label| self.body[label].name.clone()),
-                    });
-                    let ty = self.infer_block(statements, *tail, &Expectation::has_type(break_ty));
-                    let ctxt = self.breakables.pop().expect("breakable stack broken");
-                    if ctxt.may_break {
-                        ctxt.break_ty
-                    } else {
-                        ty
+            Expr::Block { statements, tail, label, id: _ } => {
+                self.resolver = resolver_for_expr(self.db.upcast(), self.owner, tgt_expr);
+                match label {
+                    Some(_) => {
+                        let break_ty = self.table.new_type_var();
+                        self.breakables.push(BreakableContext {
+                            may_break: false,
+                            break_ty: break_ty.clone(),
+                            label: label.map(|label| self.body[label].name.clone()),
+                        });
+                        let ty =
+                            self.infer_block(statements, *tail, &Expectation::has_type(break_ty));
+                        let ctxt = self.breakables.pop().expect("breakable stack broken");
+                        if ctxt.may_break {
+                            ctxt.break_ty
+                        } else {
+                            ty
+                        }
                     }
+                    None => self.infer_block(statements, *tail, expected),
                 }
-                None => self.infer_block(statements, *tail, expected),
-            },
+            }
             Expr::Unsafe { body } | Expr::Const { body } => self.infer_expr(*body, expected),
             Expr::TryBlock { body } => {
                 let _inner = self.infer_expr(*body, expected);
diff --git a/crates/hir_ty/src/tests/simple.rs b/crates/hir_ty/src/tests/simple.rs
index 16682f76fc..ab21332fbb 100644
--- a/crates/hir_ty/src/tests/simple.rs
+++ b/crates/hir_ty/src/tests/simple.rs
@@ -2415,3 +2415,22 @@ fn infer_const_params() {
         "#]],
     );
 }
+
+#[test]
+fn infer_inner_type() {
+    check_infer(r#"
+        fn foo() {
+            struct S { field: u32 }
+            let s = S { field: 0 };
+            let f = s.field;
+        }
+    "#, expect![[r#"
+        9..89 '{     ...eld; }': ()
+        47..48 's': S
+        51..65 'S { field: 0 }': S
+        62..63 '0': u32
+        75..76 'f': u32
+        79..80 's': S
+        79..86 's.field': u32
+    "#]]);
+}