Auto merge of #142701 - compiler-errors:coerce-fast, r=<try>

[perf] Fast path for coercions

Check if the goal holds before trying to walk through the goal. If it certainly holds (or certainly does not), then don't select anything.

Author: rust-bors[bot]

compiler/rustc_hir_typeck/src/coercion.rs

@@ -46,7 +46,7 @@ use rustc_hir_analysis::hir_ty_lowering::HirTyLowerer;
 use rustc_infer::infer::relate::RelateResult;
 use rustc_infer::infer::{Coercion, DefineOpaqueTypes, InferOk, InferResult};
 use rustc_infer::traits::{
-    IfExpressionCause, MatchExpressionArmCause, Obligation, PredicateObligation,
+    EvaluationResult, IfExpressionCause, MatchExpressionArmCause, Obligation, PredicateObligation,
     PredicateObligations, SelectionError,
 };
 use rustc_middle::span_bug;
@@ -597,6 +597,28 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
 
         // Create an obligation for `Source: CoerceUnsized<Target>`.
         let cause = self.cause(self.cause.span, ObligationCauseCode::Coercion { source, target });
+        let obligation = Obligation::new(
+            self.tcx,
+            cause,
+            self.fcx.param_env,
+            ty::TraitRef::new(self.tcx, coerce_unsized_did, [coerce_source, coerce_target]),
+        );
+
+        match self.evaluate_obligation_no_overflow(&obligation) {
+            EvaluationResult::EvaluatedToOk
+            | EvaluationResult::EvaluatedToOkModuloRegions
+            | EvaluationResult::EvaluatedToOkModuloOpaqueTypes => {
+                coercion.obligations.push(obligation);
+                return Ok(coercion);
+            }
+            EvaluationResult::EvaluatedToErr => {
+                return Err(TypeError::Mismatch);
+            }
+            EvaluationResult::EvaluatedToAmbig
+            | EvaluationResult::EvaluatedToAmbigStackDependent => {
+                // Continue...
+            }
+        }
 
         // Use a FIFO queue for this custom fulfillment procedure.
         //
@@ -605,12 +627,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
         // and almost never more than 3. By using a SmallVec we avoid an
         // allocation, at the (very small) cost of (occasionally) having to
         // shift subsequent elements down when removing the front element.
-        let mut queue: SmallVec<[PredicateObligation<'tcx>; 4]> = smallvec![Obligation::new(
-            self.tcx,
-            cause,
-            self.fcx.param_env,
-            ty::TraitRef::new(self.tcx, coerce_unsized_did, [coerce_source, coerce_target])
-        )];
+        let mut queue: SmallVec<[PredicateObligation<'tcx>; 4]> = smallvec![obligation];
 
         // Keep resolving `CoerceUnsized` and `Unsize` predicates to avoid
         // emitting a coercion in cases like `Foo<$1>` -> `Foo<$2>`, where