WIP

Author: jackh726

compiler/rustc_hir_typeck/src/_match.rs

@@ -178,7 +178,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         //let coerce_never = self.tcx.expr_guaranteed_to_constitute_read_for_never(expr);
         let coerce_never = true;
         tracing::debug!("calling complete in check_expr_match");
-        coercion.complete(self, &cause, coerce_never)
+        let expected = expected.coercion_target_type(self, expr.span);
+        coercion.complete(self, &cause, expected, coerce_never)
     }
 
     fn explain_never_type_coerced_to_unit(

compiler/rustc_hir_typeck/src/check.rs

@@ -136,7 +136,7 @@ pub(super) fn check_fn<'a, 'tcx>(
     let coercion = fcx.ret_coercion.take().unwrap().into_inner();
     let cause = ObligationCause::dummy();
     tracing::debug!("calling complete in check_fn");
-    let mut actual_return_ty = coercion.complete(fcx, &cause, true);
+    let mut actual_return_ty = coercion.complete(fcx, &cause, ret_ty, true);
     debug!("actual_return_ty = {:?}", actual_return_ty);
     if let ty::Dynamic(..) = declared_ret_ty.kind() {
         // We have special-cased the case where the function is declared

compiler/rustc_hir_typeck/src/closure.rs

@@ -11,11 +11,11 @@ use rustc_hir_analysis::hir_ty_lowering::HirTyLowerer;
 use rustc_infer::infer::{BoundRegionConversionTime, DefineOpaqueTypes, InferOk, InferResult};
 use rustc_infer::traits::{ObligationCauseCode, PredicateObligations};
 use rustc_macros::{TypeFoldable, TypeVisitable};
-use rustc_middle::{bug, span_bug};
 use rustc_middle::ty::{
     self, ClosureKind, GenericArgs, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable,
     TypeVisitableExt, TypeVisitor,
 };
+use rustc_middle::{bug, span_bug};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{DUMMY_SP, Span};
 use rustc_trait_selection::error_reporting::traits::ArgKind;
@@ -352,7 +352,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             _ => bug!(),
                         };
                         let output = sig.inputs_and_output.last().unwrap();
-                        let inputs_and_output = self.tcx.mk_type_list(&inputs.iter().chain([*output]).collect::<smallvec::SmallVec<[_; 4]>>());
+                        let inputs_and_output = self.tcx.mk_type_list(
+                            &inputs.iter().chain([*output]).collect::<smallvec::SmallVec<[_; 4]>>(),
+                        );
                         ty::FnSig {
                             abi: sig.abi,
                             safety: sig.safety,
@@ -368,7 +370,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 hir::ClosureKind::Coroutine(_) | hir::ClosureKind::CoroutineClosure(_) => {
                     (None, None)
                 }
-            }
+            },
             _ => (None, None),
         }
     }

compiler/rustc_hir_typeck/src/coercion.rs

@@ -817,6 +817,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             ForceLeakCheck::No,
         )?;
 
+        tracing::debug!(?coercion);
+
         // Create an obligation for `Source: CoerceUnsized<Target>`.
         let cause = self.cause(self.cause.span, ObligationCauseCode::Coercion { source, target });
         let pred = ty::TraitRef::new(self.tcx, coerce_unsized_did, [coerce_source, coerce_target]);
@@ -1270,7 +1272,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
-    fn sig_for_fn_def_coercion(
+    pub(crate) fn sig_for_fn_def_coercion(
         &self,
         fndef: Ty<'tcx>,
         expected_safety: Option<hir::Safety>,
@@ -1313,7 +1315,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
-    fn sig_for_closure_coercion(
+    pub(crate) fn sig_for_closure_coercion(
         &self,
         closure: Ty<'tcx>,
         expected_safety: Option<hir::Safety>,
@@ -1504,13 +1506,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 target
             }
             Err(coerce_mutual_err) => {
-                let new_to_expected_res = self.coerce(
-                    new,
-                    new_ty,
-                    expected_ty,
-                    AllowTwoPhase::No,
-                    Some(cause.clone()),
-                );
+                let new_to_expected_res =
+                    self.coerce(new, new_ty, expected_ty, AllowTwoPhase::No, Some(cause.clone()));
                 match new_to_expected_res {
                     Ok(t) => t,
                     Err(_) => return Err(coerce_mutual_err),
@@ -1581,7 +1578,7 @@ pub(crate) struct CoerceMany<'tcx> {
     expected_ty: Ty<'tcx>,
     final_ty: Option<Ty<'tcx>>,
     expressions: Vec<(Option<&'tcx hir::Expr<'tcx>>, Ty<'tcx>)>,
-    pub(crate) force_initial_sub: bool
+    pub(crate) initial_guidance_only: bool,
 }
 
 impl<'tcx> CoerceMany<'tcx> {
@@ -1595,7 +1592,12 @@ impl<'tcx> CoerceMany<'tcx> {
     /// Creates a `CoerceMany` with a given capacity.
     #[tracing::instrument()]
     pub(crate) fn with_capacity(expected_ty: Ty<'tcx>, capacity: usize) -> Self {
-        CoerceMany { expected_ty, final_ty: None, expressions: Vec::with_capacity(capacity), force_initial_sub: false }
+        CoerceMany {
+            expected_ty,
+            final_ty: None,
+            expressions: Vec::with_capacity(capacity),
+            initial_guidance_only: false,
+        }
     }
 
     /// Returns the "expected type" with which this coercion was
@@ -1712,16 +1714,43 @@ impl<'tcx> CoerceMany<'tcx> {
                 // 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_initial_sub {
+                if !self.initial_guidance_only {
                     fcx.coerce(
                         expression,
                         expression_ty,
                         self.expected_ty,
                         AllowTwoPhase::No,
                         Some(cause.clone()),
                     )
-                } else {
+                } else if false {
                     Ok(expression_ty)
+                } else {
+                    // See `tests/ui/coercion/expected-guidance.rs` for why this is needed.
+                    // If the expected type is e.g. `Option<?0>` and the first arm match sets it to `Option<X>`, the
+                    // second arm should be able to observe that `?0` is `X`.
+
+                    let source = fcx.try_structurally_resolve_type(expression.span, expression_ty);
+                    let target = if fcx.next_trait_solver() {
+                        fcx.try_structurally_resolve_type(cause.span, self.expected_ty)
+                    } else {
+                        self.expected_ty
+                    };
+                    let coerce_never =
+                        fcx.tcx.expr_guaranteed_to_constitute_read_for_never(expression);
+                    let guidance = crate::coercion_guidance::CoerceGuidance::new(
+                        fcx,
+                        cause.clone(),
+                        AllowTwoPhase::No,
+                        coerce_never,
+                    )
+                    .do_guidance(source, target);
+                    match guidance {
+                        Ok(ok) => {
+                            fcx.register_infer_ok_obligations(ok);
+                            Ok(source)
+                        }
+                        Err(e) => Err(e),
+                    }
                 }
             } else {
                 fcx.try_find_coercion_lub(
@@ -1749,12 +1778,7 @@ impl<'tcx> CoerceMany<'tcx> {
             // Another example is `break` with no argument expression.
             assert!(expression_ty.is_unit(), "if let hack without unit type");
             for (expr, expr_ty) in self.expressions.iter() {
-                let coerce = Coerce::new(
-                    fcx,
-                    cause.clone(),
-                    AllowTwoPhase::No,
-                    true,
-                );
+                let coerce = Coerce::new(fcx, cause.clone(), AllowTwoPhase::No, true);
                 let ok = match fcx.commit_if_ok(|_| coerce.coerce(*expr_ty, expression_ty)) {
                     Ok(coerce) => coerce,
                     Err(e) => {
@@ -1843,8 +1867,7 @@ impl<'tcx> CoerceMany<'tcx> {
                     E0069,
                     "`return;` in a function whose return type is not `()`"
                 );
-                if let Some(value) = fcx.err_ctxt().ty_kind_suggestion(fcx.param_env, found)
-                {
+                if let Some(value) = fcx.err_ctxt().ty_kind_suggestion(fcx.param_env, found) {
                     err.span_suggestion_verbose(
                         cause.span.shrink_to_hi(),
                         "give the `return` a value of the expected type",
@@ -1901,10 +1924,7 @@ impl<'tcx> CoerceMany<'tcx> {
                         rpit_def_id,
                         arm_ty,
                         prior_arm_ty,
-                        prior_non_diverging_arms
-                            .iter()
-                            .chain(std::iter::once(&arm_span))
-                            .copied(),
+                        prior_non_diverging_arms.iter().chain(std::iter::once(&arm_span)).copied(),
                     );
                 }
             }
@@ -2181,6 +2201,7 @@ impl<'tcx> CoerceMany<'tcx> {
         &self,
         fcx: &FnCtxt<'a, 'tcx>,
         cause: &ObligationCause<'tcx>,
+        mut expected_ty: Ty<'tcx>,
         coerce_never: bool,
     ) -> Ty<'tcx> {
         let Some(final_ty) = self.final_ty else {
@@ -2190,69 +2211,70 @@ impl<'tcx> CoerceMany<'tcx> {
             return fcx.tcx.types.never;
         };
 
-        if self.force_initial_sub {
+        if !self.initial_guidance_only {
             return final_ty;
         }
-        
-        let mut expected_ty = self.expected_ty;
-        if fcx.next_trait_solver() {
-            expected_ty = fcx.try_structurally_resolve_type(
-                cause.span,
-                expected_ty,
-            );
+
+        if true {
+            //return final_ty;
         }
 
-        // You may ask "Why do we coerce the `final_ty` to the `expected_ty`, and
-        // then *also* each expression ty to the `expected_ty`?".
-        // TODO: investigate and validate the following claim
-        // Basically, if `expected_ty` is an inference variable, then a coercion
-        // with the first arm can constrain that because of the `unify` fallback.
+        if fcx.next_trait_solver() {
+            expected_ty = fcx.try_structurally_resolve_type(cause.span, expected_ty);
+        }
 
         let final_ty = fcx.try_structurally_resolve_type(cause.span, final_ty);
+        let expected_ty = fcx.try_structurally_resolve_type(cause.span, expected_ty);
         debug!("coerce::complete (final_ty): {:?} -> {:?}", final_ty, expected_ty);
 
-        let coerce = Coerce::new(
-            fcx,
-            cause.clone(),
-            AllowTwoPhase::No,
-            coerce_never,
-        );
-        let ok = match fcx.commit_if_ok(|_| coerce.coerce(final_ty, expected_ty)) {
-            Ok(coerce) => coerce,
-            Err(err) => {
-                let reported = self.report_coercion_error(
-                    fcx,
-                    err,
-                    cause,
-                    None,
-                    expected_ty,
-                    final_ty,
-                    |_| {}
-                );
-                return Ty::new_error(fcx.tcx, reported);
-            }
-        };
-        let _ = fcx.register_infer_ok_obligations(ok);
+        if true {
+            // You may ask "Why do we coerce the `final_ty` to the `expected_ty`, and
+            // then *also* each expression ty to the `expected_ty`?".
+            // TODO: investigate and validate the following claim
+            // Basically, if `expected_ty` is an inference variable, then a coercion
+            // with the first arm can constrain that because of the `unify` fallback.
+
+            let coerce = Coerce::new(fcx, cause.clone(), AllowTwoPhase::No, coerce_never);
+            let ok = match fcx.commit_if_ok(|_| coerce.coerce(final_ty, expected_ty)) {
+                Ok(coerce) => coerce,
+                Err(err) => {
+                    let reported = self.report_coercion_error(
+                        fcx,
+                        err,
+                        cause,
+                        None,
+                        expected_ty,
+                        final_ty,
+                        |_| {},
+                    );
+                    return Ty::new_error(fcx.tcx, reported);
+                }
+            };
+            let _ = fcx.register_infer_ok_obligations(ok);
+        }
 
         for (expr, ty) in self.expressions.iter() {
             let source = fcx.try_structurally_resolve_type(cause.span, *ty);
             debug!("coerce::complete (expression): {:?} -> {:?}", source, expected_ty);
 
-            let coerce = Coerce::new(
-                fcx,
-                cause.clone(),
-                AllowTwoPhase::No,
-                coerce_never,
-            );
+            let coerce = Coerce::new(fcx, cause.clone(), AllowTwoPhase::No, coerce_never);
             let ok = match fcx.commit_if_ok(|_| coerce.coerce(source, expected_ty)) {
                 Ok(coerce) => coerce,
                 Err(e) => {
-                    let reported = self.report_coercion_error(fcx, e, cause, *expr, expected_ty, source, |_| {});
+                    let reported = self.report_coercion_error(
+                        fcx,
+                        e,
+                        cause,
+                        *expr,
+                        expected_ty,
+                        source,
+                        |_| {},
+                    );
                     return Ty::new_error(fcx.tcx, reported);
                 }
             };
             let (adjustments, _) = fcx.register_infer_ok_obligations(ok);
-    
+
             if let Some(expr) = expr {
                 fcx.set_adjustments(expr, adjustments.clone());
             }
@@ -2263,17 +2285,17 @@ impl<'tcx> CoerceMany<'tcx> {
         if let Err(guar) = final_ty.error_reported() {
             Ty::new_error(fcx.tcx, guar)
         } else {
-            self.expected_ty
+            expected_ty
         }
     }
 }
 
 /// Recursively visit goals to decide whether an unsizing is possible.
 /// `Break`s when it isn't, and an error should be raised.
 /// `Continue`s when an unsizing ok based on an implementation of the `Unsize` trait / lang item.
-struct CoerceVisitor<'a, 'tcx> {
-    fcx: &'a FnCtxt<'a, 'tcx>,
-    span: Span,
+pub(crate) struct CoerceVisitor<'a, 'tcx> {
+    pub(crate) fcx: &'a FnCtxt<'a, 'tcx>,
+    pub(crate) span: Span,
 }
 
 impl<'tcx> ProofTreeVisitor<'tcx> for CoerceVisitor<'_, 'tcx> {