make array coercion consistent with if and match

Author: adwinwhite

compiler/rustc_hir_typeck/src/expr.rs

@@ -1825,15 +1825,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         .filter(|t| !self.try_structurally_resolve_type(expr.span, *t).is_ty_var())
                 })
                 .unwrap_or_else(|| self.next_ty_var(expr.span));
+            let element_expected = Expectation::ExpectHasType(coerce_to)
+                .try_structurally_resolve_and_adjust_for_branches(self, expr.span);
             let mut coerce = CoerceMany::with_coercion_sites(coerce_to, args);
             assert_eq!(self.diverges.get(), Diverges::Maybe);
             for e in args {
-                // FIXME: the element expectation should use
-                // `try_structurally_resolve_and_adjust_for_branches` just like in `if` and `match`.
-                // While that fixes nested coercion, it will break [some
-                // code like this](https://github.com/rust-lang/rust/pull/140283#issuecomment-2958776528).
-                // If we find a way to support recursive tuple coercion, this break can be avoided.
-                let e_ty = self.check_expr_with_hint(e, coerce_to);
+                let e_ty = self.check_expr_with_expectation(e, element_expected);
                 let cause = self.misc(e.span);
                 coerce.coerce(self, &cause, e, e_ty);
             }

tests/ui/coercion/coerce-many-with-ty-var.rs

@@ -13,6 +13,7 @@ fn main() {
     // Previously the element type's ty var will be unified with `foo`.
     let _: [_; 2] = [foo, bar];
     infer_array_element([foo, bar]);
+    let _ = [foo, if false { bar } else { foo }];
 
     let _ = if false {
         foo
@@ -24,6 +25,16 @@ fn main() {
     } else {
         bar
     });
+    let _ = if false {
+        foo
+    } else {
+        if false {
+            bar
+        } else {
+            foo
+        }
+    };
+
 
     let _ = match false {
         true => foo,
@@ -33,6 +44,12 @@ fn main() {
         true => foo,
         false => bar,
     });
-
-
+    let _ = match 1 {
+        2 => foo,
+        _ => if false {
+            bar
+        } else {
+            foo
+        },
+    };
 }

tests/ui/coercion/coerce-unify.rs

@@ -62,7 +62,4 @@ pub fn main() {
     let a = [1, 2, 3];
     let v = vec![1, 2, 3];
     check2!(&a[..], &v);
-
-    // Make sure in-array coercion still works.
-    let _ = [("a", Default::default()), (Default::default(), "b"), (&s, &s)];
 }

tests/ui/repeat-expr/typo-in-repeat-expr-issue-80173.stderr

@@ -103,7 +103,7 @@ error[E0308]: mismatched types
   --> $DIR/typo-in-repeat-expr-issue-80173.rs:57:23
    |
 LL |     let k = vec!['c', 10];
-   |                       ^^ expected `char`, found `u8`
+   |                       ^^ expected `char`, found integer
    |
 help: replace the comma with a semicolon to create a vector
    |