Always use LUB for match arms

Author: jackh726

compiler/rustc_hir_typeck/src/_match.rs

@@ -75,6 +75,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             };
             CoerceMany::with_coercion_sites(coerce_first, arms)
         };
+        coercion.force_lub();
 
         let mut prior_non_diverging_arms = vec![]; // Used only for diagnostics.
         let mut prior_arm = None;

compiler/rustc_hir_typeck/src/coercion.rs

@@ -1387,6 +1387,7 @@ pub(crate) struct CoerceMany<'tcx, 'exprs, E: AsCoercionSite> {
     final_ty: Option<Ty<'tcx>>,
     expressions: Expressions<'tcx, 'exprs, E>,
     pushed: usize,
+    force_lub: bool,
 }
 
 /// The type of a `CoerceMany` that is storing up the expressions into
@@ -1416,7 +1417,13 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
     }
 
     fn make(expected_ty: Ty<'tcx>, expressions: Expressions<'tcx, 'exprs, E>) -> Self {
-        CoerceMany { expected_ty, final_ty: None, expressions, pushed: 0 }
+        CoerceMany { expected_ty, final_ty: None, expressions, pushed: 0, force_lub: false }
+    }
+
+    pub(crate) fn force_lub(&mut self) {
+        // Don't accidentally let someone switch this after coercing things
+        assert_eq!(self.pushed, 0);
+        self.force_lub = true;
     }
 
     /// Returns the "expected type" with which this coercion was
@@ -1529,10 +1536,9 @@ impl<'tcx, 'exprs, E: AsCoercionSite> CoerceMany<'tcx, 'exprs, E> {
 
         // Handle the actual type unification etc.
         let result = if let Some(expression) = expression {
-            if self.pushed == 0 {
-                // Special-case the first expression we are coercing.
-                // To be honest, I'm not entirely sure why we do this.
-                // We don't allow two-phase borrows, see comment in try_find_coercion_lub for why
+            if !self.force_lub && self.pushed == 0 {
+                // For this *first* expression, we do *not* use LUB
+                // (which `try_find_coercion_lub` does).
                 fcx.coerce(
                     expression,
                     expression_ty,

tests/ui/coercion/coerce-loop-issue-122561.stderr

@@ -90,12 +90,6 @@ LL | |     }
    |
    = note:   expected type `!`
            found unit type `()`
-   = note: `for` loops evaluate to unit type `()`
-help: consider adding a diverging expression here
-   |
-LL ~     }
-LL +     /* `loop {}` or `panic!("...")` */
-   |
 
 error[E0308]: mismatched types
   --> $DIR/coerce-loop-issue-122561.rs:35:32

tests/ui/issues/issue-28839.rs

@@ -1,12 +1,20 @@
-//@ run-pass
+//@ check-fail
 
 pub struct Foo;
 
-pub fn get_foo2<'a>(foo: &'a mut Option<&'a mut Foo>) -> &'a mut Foo {
+pub fn get_foo1<'a>(foo: &'a mut Option<&'a mut Foo>) -> &'a mut Foo {
     match foo {
-        // Ensure that this is not considered a move, but rather a reborrow.
         &mut Some(ref mut x) => *x,
+        //~^ ERROR cannot move out of
+        &mut None => panic!(),
+    }
+}
+
+pub fn get_foo2<'a>(foo: &'a mut Option<&'a mut Foo>) -> &'a mut Foo {
+    match foo {
         &mut None => panic!(),
+        &mut Some(ref mut x) => *x,
+        //~^ ERROR cannot move out of
     }
 }
 

tests/ui/issues/issue-28839.stderr

@@ -0,0 +1,15 @@
+error[E0507]: cannot move out of `*x` which is behind a mutable reference
+  --> $DIR/issue-28839.rs:7:33
+   |
+LL |         &mut Some(ref mut x) => *x,
+   |                                 ^^ move occurs because `*x` has type `&mut Foo`, which does not implement the `Copy` trait
+
+error[E0507]: cannot move out of `*x` which is behind a mutable reference
+  --> $DIR/issue-28839.rs:16:33
+   |
+LL |         &mut Some(ref mut x) => *x,
+   |                                 ^^ move occurs because `*x` has type `&mut Foo`, which does not implement the `Copy` trait
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0507`.

tests/ui/nll/issue-52213.rs

@@ -1,7 +1,7 @@
 fn transmute_lifetime<'a, 'b, T>(t: &'a (T,)) -> &'b T {
     match (&t,) {
-        ((u,),) => u,
         //~^ ERROR lifetime may not live long enough
+        ((u,),) => u,
     }
 }
 

tests/ui/nll/issue-52213.stderr

@@ -1,13 +1,15 @@
 error: lifetime may not live long enough
-  --> $DIR/issue-52213.rs:3:20
+  --> $DIR/issue-52213.rs:2:5
    |
-LL | fn transmute_lifetime<'a, 'b, T>(t: &'a (T,)) -> &'b T {
-   |                       --  -- lifetime `'b` defined here
-   |                       |
-   |                       lifetime `'a` defined here
-LL |     match (&t,) {
-LL |         ((u,),) => u,
-   |                    ^ function was supposed to return data with lifetime `'b` but it is returning data with lifetime `'a`
+LL |   fn transmute_lifetime<'a, 'b, T>(t: &'a (T,)) -> &'b T {
+   |                         --  -- lifetime `'b` defined here
+   |                         |
+   |                         lifetime `'a` defined here
+LL | /     match (&t,) {
+LL | |
+LL | |         ((u,),) => u,
+LL | |     }
+   | |_____^ function was supposed to return data with lifetime `'b` but it is returning data with lifetime `'a`
    |
    = help: consider adding the following bound: `'a: 'b`