Auto merge of #147834 - WaffleLapkin:tuple-coerce, r=BoxyUwU

Always make tuple elements a coercion site





Previously we only used `check_expr_coercible_to_type` if we had an expectation (using `check_expr_with_expectation(NoExpectation)` otherwise). Normally that'd be fine, because without an expectation we can't insert a coercion anyway. However, for the case of never-to-any coercion specifically, we _do_ insert it eagerly, so this prevents some code from compiling, for example:

```rust
((),) = (loop {},);
```

With this PR we are always using `check_expr_coercible_to_type` (using an infer var if there is no expectation), which allows slightly more code to compile.

Fixes #112856

r? BoxyUwU

Author: bors

compiler/rustc_hir_typeck/src/expr.rs

@@ -1792,27 +1792,24 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
     fn check_expr_tuple(
         &self,
-        elts: &'tcx [hir::Expr<'tcx>],
+        elements: &'tcx [hir::Expr<'tcx>],
         expected: Expectation<'tcx>,
         expr: &'tcx hir::Expr<'tcx>,
     ) -> Ty<'tcx> {
-        let flds = expected.only_has_type(self).and_then(|ty| {
-            let ty = self.try_structurally_resolve_type(expr.span, ty);
-            match ty.kind() {
-                ty::Tuple(flds) => Some(&flds[..]),
-                _ => None,
-            }
+        let mut expectations = expected
+            .only_has_type(self)
+            .and_then(|ty| self.try_structurally_resolve_type(expr.span, ty).opt_tuple_fields())
+            .unwrap_or_default()
+            .iter();
+
+        let elements = elements.iter().map(|e| {
+            let ty = expectations.next().unwrap_or_else(|| self.next_ty_var(e.span));
+            self.check_expr_coercible_to_type(e, ty, None);
+            ty
         });
 
-        let elt_ts_iter = elts.iter().enumerate().map(|(i, e)| match flds {
-            Some(fs) if i < fs.len() => {
-                let ety = fs[i];
-                self.check_expr_coercible_to_type(e, ety, None);
-                ety
-            }
-            _ => self.check_expr_with_expectation(e, NoExpectation),
-        });
-        let tuple = Ty::new_tup_from_iter(self.tcx, elt_ts_iter);
+        let tuple = Ty::new_tup_from_iter(self.tcx, elements);
+
         if let Err(guar) = tuple.error_reported() {
             Ty::new_error(self.tcx, guar)
         } else {

compiler/rustc_middle/src/ty/sty.rs

@@ -1592,7 +1592,8 @@ impl<'tcx> Ty<'tcx> {
         }
     }
 
-    /// Iterates over tuple fields.
+    /// Returns a list of tuple type arguments.
+    ///
     /// Panics when called on anything but a tuple.
     #[inline]
     pub fn tuple_fields(self) -> &'tcx List<Ty<'tcx>> {
@@ -1602,6 +1603,15 @@ impl<'tcx> Ty<'tcx> {
         }
     }
 
+    /// Returns a list of tuple type arguments, or `None` if `self` isn't a tuple.
+    #[inline]
+    pub fn opt_tuple_fields(self) -> Option<&'tcx List<Ty<'tcx>>> {
+        match self.kind() {
+            Tuple(args) => Some(args),
+            _ => None,
+        }
+    }
+
     /// If the type contains variants, returns the valid range of variant indices.
     //
     // FIXME: This requires the optimized MIR in the case of coroutines.

tests/ui/loops/loop-break-value.stderr

@@ -232,10 +232,10 @@ LL |         break (break, break);
    |               ||      |
    |               ||      expected because of this `break`
    |               |expected because of this `break`
-   |               expected `()`, found `(!, !)`
+   |               expected `()`, found `(_, _)`
    |
    = note: expected unit type `()`
-                  found tuple `(!, !)`
+                  found tuple `(_, _)`
 
 error[E0308]: mismatched types
   --> $DIR/loop-break-value.rs:89:15

tests/ui/never_type/regress/divergent-block-with-tail.stderr

@@ -22,10 +22,10 @@ error[E0308]: mismatched types
 LL | fn f() -> isize {
    |           ----- expected `isize` because of return type
 LL |     (return 1, return 2)
-   |     ^^^^^^^^^^^^^^^^^^^^ expected `isize`, found `(!, !)`
+   |     ^^^^^^^^^^^^^^^^^^^^ expected `isize`, found `(_, _)`
    |
    = note: expected type `isize`
-             found tuple `(!, !)`
+             found tuple `(_, _)`
 
 error: aborting due to 2 previous errors
 

tests/ui/tuple/array-diagnostics.rs

@@ -1,7 +1,7 @@
 fn main() {
     let _tmp = [
         ("C200B40A82", 3),
-        ("C200B40A83", 4) //~ ERROR: expected function, found `(&'static str, {integer})` [E0618]
+        ("C200B40A83", 4) //~ ERROR: expected function, found `(&str, {integer})` [E0618]
         ("C200B40A8537", 5),
     ];
 }

tests/ui/tuple/array-diagnostics.stderr

@@ -1,4 +1,4 @@
-error[E0618]: expected function, found `(&'static str, {integer})`
+error[E0618]: expected function, found `(&str, {integer})`
   --> $DIR/array-diagnostics.rs:4:9
    |
 LL |         ("C200B40A83", 4)

tests/ui/tuple/coercion-never.rs

@@ -0,0 +1,16 @@
+// This test checks if tuple elements are a coercion site or not.
+// Note that the code here is a degenerate case, but you can get similar effects in real code, when
+// unifying match arms, for example.
+//
+// See also coercion-slice.rs
+//
+//@ check-pass
+
+fn main() {
+    let _: ((),) = (loop {},);
+
+    ((),) = (loop {},);
+
+    let x = (loop {},);
+    let _: ((),) = x;
+}

tests/ui/tuple/coercion-slice.rs

@@ -0,0 +1,12 @@
+// This test checks if tuple elements are a coercion site or not.
+// Note that the code here is a degenerate case, but you can get similar effects in real code, when
+// unifying match arms, for example.
+//
+// See also: coercion-never.rs
+
+fn main() {
+    let _: (&[u8],) = (&[],);
+
+    let y = (&[],);
+    let _: (&[u8],) = y; //~ error: mismatched types
+}

tests/ui/tuple/coercion-slice.stderr

@@ -0,0 +1,14 @@
+error[E0308]: mismatched types
+  --> $DIR/coercion-slice.rs:11:23
+   |
+LL |     let _: (&[u8],) = y;
+   |            --------   ^ expected `(&[u8],)`, found `(&[_; 0],)`
+   |            |
+   |            expected due to this
+   |
+   = note: expected tuple `(&[u8],)`
+              found tuple `(&[_; 0],)`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.