Attempt to coerce to final LUB type

Author: jackh726

compiler/rustc_hir_typeck/src/coercion.rs

@@ -1168,7 +1168,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     fn try_find_coercion_lub(
         &self,
         cause: &ObligationCause<'tcx>,
-        exprs: &[&'tcx hir::Expr<'tcx>],
+        exprs: &[(&'tcx hir::Expr<'tcx>, Ty<'tcx>)],
         prev_ty: Ty<'tcx>,
         new: &hir::Expr<'_>,
         new_ty: Ty<'tcx>,
@@ -1266,7 +1266,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 ty::FnDef(..) => Adjust::Pointer(PointerCoercion::ReifyFnPointer(sig.safety())),
                 _ => span_bug!(new.span, "should not try to coerce a {new_ty} to a fn pointer"),
             };
-            for expr in exprs.iter() {
+            for (expr, _expr_ty) in exprs.iter() {
                 self.apply_adjustments(
                     expr,
                     vec![Adjustment { kind: prev_adjustment.clone(), target: fn_ptr }],
@@ -1306,14 +1306,25 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
         }
 
+        // This is maybe not the *most correct* thing to do. Taking match arm checking as an example:
+        // This means that at each match arm, either the new arm ty must coerce into the current LUB (above),
+        // or the current LUB can be coerced into the new arm ty. What we *probably* actually want is that each arm
+        // can be coerced to the final LUB. Importantly, I can imagine a case where some arm can only be coered to some
+        // final LUB, but not some intermediate LUB - and that would fail here.
         let ok = self
             .commit_if_ok(|_| coerce.coerce(prev_ty, new_ty))
             // Avoid giving strange errors on failed attempts.
             .map_err(|e| first_error.unwrap_or(e))?;
-
-        let (adjustments, target) = self.register_infer_ok_obligations(ok);
-        for expr in exprs {
-            self.apply_adjustments(expr, adjustments.clone());
+        let (_, target) = self.register_infer_ok_obligations(ok);
+
+        for (expr, expr_ty) in exprs {
+            let ok = self
+                .commit_if_ok(|_| coerce.coerce(*expr_ty, new_ty))
+                // Avoid giving strange errors on failed attempts.
+                .map_err(|e| first_error.unwrap_or(e))?;
+            let (adj, _) = self.register_infer_ok_obligations(ok);
+            debug!(?expr_ty, ?new_ty);
+            self.set_adjustments(*expr, adj);
         }
         debug!(
             "coercion::try_find_coercion_lub: was able to coerce previous type {:?} to new type {:?} ({:?})",
@@ -1381,7 +1392,7 @@ pub fn can_coerce<'tcx>(
 pub(crate) struct CoerceMany<'tcx> {
     expected_ty: Ty<'tcx>,
     final_ty: Option<Ty<'tcx>>,
-    expressions: Vec<&'tcx hir::Expr<'tcx>>,
+    expressions: Vec<(&'tcx hir::Expr<'tcx>, Ty<'tcx>)>,
 }
 
 impl<'tcx> CoerceMany<'tcx> {
@@ -1560,7 +1571,7 @@ impl<'tcx> CoerceMany<'tcx> {
             Ok(v) => {
                 self.final_ty = Some(v);
                 if let Some(e) = expression {
-                    self.expressions.push(e);
+                    self.expressions.push((e, expression_ty));
                 }
             }
             Err(coercion_error) => {

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -364,6 +364,70 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
+    #[instrument(skip(self, expr), level = "debug")]
+    pub(crate) fn set_adjustments(&self, expr: &hir::Expr<'_>, adj: Vec<Adjustment<'tcx>>) {
+        debug!("expr = {:#?}", expr);
+
+        if adj.is_empty() {
+            return;
+        }
+
+        let mut expr_ty = self.typeck_results.borrow().expr_ty_adjusted(expr);
+
+        for a in &adj {
+            match a.kind {
+                Adjust::NeverToAny => {
+                    if a.target.is_ty_var() {
+                        self.diverging_type_vars.borrow_mut().insert(a.target);
+                        debug!("apply_adjustments: adding `{:?}` as diverging type var", a.target);
+                    }
+                }
+                Adjust::Deref(Some(overloaded_deref)) => {
+                    self.enforce_context_effects(
+                        None,
+                        expr.span,
+                        overloaded_deref.method_call(self.tcx),
+                        self.tcx.mk_args(&[expr_ty.into()]),
+                    );
+                }
+                Adjust::Deref(None) => {
+                    // FIXME(const_trait_impl): We *could* enforce `&T: [const] Deref` here.
+                }
+                Adjust::Pointer(_pointer_coercion) => {
+                    // FIXME(const_trait_impl): We should probably enforce these.
+                }
+                Adjust::ReborrowPin(_mutability) => {
+                    // FIXME(const_trait_impl): We could enforce these; they correspond to
+                    // `&mut T: DerefMut` tho, so it's kinda moot.
+                }
+                Adjust::Borrow(_) => {
+                    // No effects to enforce here.
+                }
+            }
+
+            expr_ty = a.target;
+        }
+
+        let autoborrow_mut = adj.iter().any(|adj| {
+            matches!(
+                adj,
+                &Adjustment {
+                    kind: Adjust::Borrow(AutoBorrow::Ref(AutoBorrowMutability::Mut { .. })),
+                    ..
+                }
+            )
+        });
+
+        self.typeck_results.borrow_mut().adjustments_mut().insert(expr.hir_id, adj);
+
+        // If there is an mutable auto-borrow, it is equivalent to `&mut <expr>`.
+        // In this case implicit use of `Deref` and `Index` within `<expr>` should
+        // instead be `DerefMut` and `IndexMut`, so fix those up.
+        if autoborrow_mut {
+            self.convert_place_derefs_to_mutable(expr);
+        }
+    }
+
     /// Instantiates and normalizes the bounds for a given item
     pub(crate) fn instantiate_bounds(
         &self,

tests/ui/coercion/multistep.fail.stderr

@@ -1,16 +1,37 @@
 error[E0277]: the trait bound `TopTypeNoTrait: Dynable` is not satisfied
-  --> $DIR/multistep.rs:479:14
+  --> $DIR/multistep.rs:449:18
+   |
+LL |             2 => &TopTypeNoTrait as &FinalType as &dyn Dynable,
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unsatisfied trait bound
+   |
+help: the trait `Dynable` is not implemented for `TopTypeNoTrait`
+  --> $DIR/multistep.rs:73:1
+   |
+LL | struct TopTypeNoTrait;
+   | ^^^^^^^^^^^^^^^^^^^^^
+help: the following other types implement trait `Dynable`
+  --> $DIR/multistep.rs:38:1
+   |
+LL | impl Dynable for Inner {}
+   | ^^^^^^^^^^^^^^^^^^^^^^ `Inner`
+...
+LL | impl Dynable for FinalType {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^ `FinalType`
+   = note: required for the cast from `&TopTypeNoTrait` to `&dyn Dynable`
+
+error[E0277]: the trait bound `TopTypeNoTrait: Dynable` is not satisfied
+  --> $DIR/multistep.rs:476:14
    |
 LL |         1 => &TopTypeNoTrait as &FinalType as &dyn Dynable,
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unsatisfied trait bound
    |
 help: the trait `Dynable` is not implemented for `TopTypeNoTrait`
-  --> $DIR/multistep.rs:76:1
+  --> $DIR/multistep.rs:73:1
    |
 LL | struct TopTypeNoTrait;
    | ^^^^^^^^^^^^^^^^^^^^^
 help: the following other types implement trait `Dynable`
-  --> $DIR/multistep.rs:41:1
+  --> $DIR/multistep.rs:38:1
    |
 LL | impl Dynable for Inner {}
    | ^^^^^^^^^^^^^^^^^^^^^^ `Inner`
@@ -20,7 +41,7 @@ LL | impl Dynable for FinalType {}
    = note: required for the cast from `&TopTypeNoTrait` to `&dyn Dynable`
 
 error[E0308]: `match` arms have incompatible types
-  --> $DIR/multistep.rs:489:14
+  --> $DIR/multistep.rs:486:14
    |
 LL | /     match 0 {
 LL | |         0 => &A          as &A,
@@ -37,15 +58,34 @@ LL | |     };
    = note: expected reference `&B`
               found reference `&C`
 
+error[E0308]: `match` arms have incompatible types
+  --> $DIR/multistep.rs:539:18
+   |
+LL |           |i| match i {
+   |  _____________-
+LL | |             0 => &E          as &E,
+   | |                  ----------------- this is found to be of type `&Wrap2<[i32; 0]>`
+LL | |             1 => &Wrap2([])  as &F,
+   | |                  ----------------- this is found to be of type `&Wrap2<[i32; 0]>`
+LL | |             3 => &Wrap2([])  as &H,
+   | |                  ^^^^^^^^^^^^^^^^^ expected `&Wrap2<[i32; 0]>`, found `&Wrap2<[i32]>`
+LL | |             2 => &G          as &G,
+LL | |             _ => loop {},
+LL | |         }.complete(),
+   | |_________- `match` arms have incompatible types
+   |
+   = note: expected reference `&Wrap2<[i32; 0]>`
+              found reference `&Wrap2<[i32]>`
+
 error[E0055]: reached the recursion limit while auto-dereferencing `P`
-  --> $DIR/multistep.rs:623:14
+  --> $DIR/multistep.rs:620:14
    |
 LL |         1 => &P      as &P,
    |              ^^^^^^^^^^^^^ deref recursion limit reached
    |
    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]` attribute to your crate (`multistep`)
 
-error: aborting due to 3 previous errors
+error: aborting due to 5 previous errors
 
 Some errors have detailed explanations: E0055, E0277, E0308.
 For more information about an error, try `rustc --explain E0055`.