Auto merge of #150408 - jackh726:multistep-coercion-cleanup, r=<try>

[CRATER] Require equality for symmetric LUB coercion

Author: bors

compiler/rustc_hir_typeck/src/_match.rs

@@ -174,7 +174,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // We won't diverge unless the scrutinee or all arms diverge.
         self.diverges.set(scrut_diverges | all_arms_diverge);
 
-        coercion.complete(self)
+        let cause = ObligationCause::dummy();
+        //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)
     }
 
     fn explain_never_type_coerced_to_unit(

compiler/rustc_hir_typeck/src/check.rs

@@ -134,7 +134,9 @@ pub(super) fn check_fn<'a, 'tcx>(
     // really expected to fail, since the coercions would have failed
     // earlier when trying to find a LUB.
     let coercion = fcx.ret_coercion.take().unwrap().into_inner();
-    let mut actual_return_ty = coercion.complete(fcx);
+    let cause = ObligationCause::dummy();
+    tracing::debug!("calling complete in check_fn");
+    let mut actual_return_ty = coercion.complete(fcx, &cause, 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,7 +11,7 @@ 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::span_bug;
+use rustc_middle::{bug, span_bug};
 use rustc_middle::ty::{
     self, ClosureKind, GenericArgs, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable,
     TypeVisitableExt, TypeVisitor,
@@ -340,6 +340,35 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     (None, None)
                 }
             },
+            ty::Closure(_, args) => match closure_kind {
+                hir::ClosureKind::Closure => {
+                    let closure_args = args.as_closure();
+                    let sig = closure_args.sig();
+                    tracing::debug!(?closure_args, ?sig);
+                    let sig = sig.map_bound(|sig| {
+                        let inputs = sig.inputs_and_output.first().unwrap();
+                        let inputs = match inputs.kind() {
+                            ty::Tuple(tys) => tys,
+                            _ => 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]>>());
+                        ty::FnSig {
+                            abi: sig.abi,
+                            safety: sig.safety,
+                            c_variadic: sig.c_variadic,
+                            inputs_and_output,
+                        }
+                    });
+                    tracing::debug!(?sig);
+                    let expected_sig = ExpectedSig { cause_span: None, sig };
+                    let kind = closure_args.kind_ty().to_opt_closure_kind();
+                    (Some(expected_sig), kind)
+                }
+                hir::ClosureKind::Coroutine(_) | hir::ClosureKind::CoroutineClosure(_) => {
+                    (None, None)
+                }
+            }
             _ => (None, None),
         }
     }