always make tuple elements a coercion site

Author: WaffleLapkin

compiler/rustc_hir_typeck/src/expr.rs

@@ -1939,27 +1939,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).tuple())
+            .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

@@ -1560,7 +1560,8 @@ impl<'tcx> Ty<'tcx> {
         }
     }
 
-    /// Iterates over tuple fields.
+    /// Returns a list of tuple fields.
+    ///
     /// Panics when called on anything but a tuple.
     #[inline]
     pub fn tuple_fields(self) -> &'tcx List<Ty<'tcx>> {
@@ -1570,6 +1571,15 @@ impl<'tcx> Ty<'tcx> {
         }
     }
 
+    /// Returns a list of tuple type arguments, or `None` if `self` isn't a tuple.
+    #[inline]
+    pub fn tuple(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/diverging-tuple-parts-39485.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/never_type/issue-10176.rs

@@ -2,8 +2,8 @@ fn f() -> isize { //~ NOTE expected `isize` because of return type
     (return 1, return 2)
 //~^ ERROR mismatched types
 //~| NOTE expected type `isize`
-//~| NOTE found tuple `(!, !)`
-//~| NOTE expected `isize`, found `(!, !)`
+//~| NOTE found tuple `(_, _)`
+//~| NOTE expected `isize`, found `(_, _)`
 }
 
 fn main() {}

tests/ui/never_type/issue-10176.stderr

@@ -4,10 +4,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 1 previous error
 

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.rs

@@ -5,13 +5,17 @@
 fn main() {
     let _: ((),) = (loop {},);
 
-    ((),) = (loop {},); //~ error: mismatched types
+    ((),) = (loop {},);
 
     let x = (loop {},);
-    let _: ((),) = x; //~ error: mismatched types
+    let _: ((),) = x;
 
     let _: (&[u8],) = (&[],);
 
+    // This one can't work without a redesign on the coercion system.
+    // We currently only eagerly add never-to-any coercions, not any others.
+    // Thus, because we don't have an expectation when typechecking `&[]`,
+    // we don't add a coercion => this doesn't work.
     let y = (&[],);
     let _: (&[u8],) = y; //~ error: mismatched types
 }

tests/ui/tuple/coercion.stderr

@@ -1,27 +1,5 @@
 error[E0308]: mismatched types
-  --> $DIR/coercion.rs:8:6
-   |
-LL |     ((),) = (loop {},);
-   |      ^^     ---------- this expression has type `(!,)`
-   |      |
-   |      expected `!`, found `()`
-   |
-   = note:   expected type `!`
-           found unit type `()`
-
-error[E0308]: mismatched types
-  --> $DIR/coercion.rs:11:20
-   |
-LL |     let _: ((),) = x;
-   |            -----   ^ expected `((),)`, found `(!,)`
-   |            |
-   |            expected due to this
-   |
-   = note: expected tuple `((),)`
-              found tuple `(!,)`
-
-error[E0308]: mismatched types
-  --> $DIR/coercion.rs:16:23
+  --> $DIR/coercion.rs:20:23
    |
 LL |     let _: (&[u8],) = y;
    |            --------   ^ expected `(&[u8],)`, found `(&[_; 0],)`
@@ -31,6 +9,6 @@ LL |     let _: (&[u8],) = y;
    = note: expected tuple `(&[u8],)`
               found tuple `(&[_; 0],)`
 
-error: aborting due to 3 previous errors
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0308`.