shallow resolve in orphan check

compiler/rustc_trait_selection/src/solve/assembly/mod.rs

@@ -2,7 +2,6 @@
 
 use crate::solve::GoalSource;
 use crate::solve::{inspect, EvalCtxt, SolverMode};
-use crate::traits::coherence;
 use rustc_hir::def_id::DefId;
 use rustc_infer::traits::query::NoSolution;
 use rustc_middle::traits::solve::inspect::ProbeKind;
@@ -769,13 +768,10 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
         candidates.extend(self.probe_trait_candidate(CandidateSource::CoherenceUnknowable).enter(
             |ecx| {
                 let trait_ref = goal.predicate.trait_ref(tcx);
-                let lazily_normalize_ty = |ty| ecx.structurally_normalize_ty(goal.param_env, ty);
-
-                match coherence::trait_ref_is_knowable(tcx, trait_ref, lazily_normalize_ty)? {
-                    Ok(()) => Err(NoSolution),
-                    Err(_) => {
-                        ecx.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)
-                    }
+                if ecx.trait_ref_is_knowable(goal.param_env, trait_ref)? {
+                    Err(NoSolution)
+                } else {
+                    ecx.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS)
                 }
             },
         ))

compiler/rustc_trait_selection/src/solve/eval_ctxt/mod.rs

@@ -27,6 +27,7 @@ use rustc_span::DUMMY_SP;
 use std::io::Write;
 use std::ops::ControlFlow;
 
+use crate::traits::coherence;
 use crate::traits::vtable::{count_own_vtable_entries, prepare_vtable_segments, VtblSegment};
 
 use super::inspect::ProofTreeBuilder;
@@ -942,6 +943,17 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
         }
     }
 
+    pub(super) fn trait_ref_is_knowable(
+        &mut self,
+        param_env: ty::ParamEnv<'tcx>,
+        trait_ref: ty::TraitRef<'tcx>,
+    ) -> Result<bool, NoSolution> {
+        let infcx = self.infcx;
+        let lazily_normalize_ty = |ty| self.structurally_normalize_ty(param_env, ty);
+        coherence::trait_ref_is_knowable(infcx, trait_ref, lazily_normalize_ty)
+            .map(|is_knowable| is_knowable.is_ok())
+    }
+
     pub(super) fn can_define_opaque_ty(&self, def_id: impl Into<DefId>) -> bool {
         self.infcx.can_define_opaque_ty(def_id)
     }