Auto merge of #147502 - camsteffen:split-overlapping-impls, r=<try>

Split overlapping_{inherent,trait}_impls

Author: rust-bors[bot]

compiler/rustc_hir_analysis/src/coherence/inherent_impls_overlap.rs

@@ -154,7 +154,7 @@ impl<'tcx> InherentOverlapChecker<'tcx> {
         impl1_def_id: DefId,
         impl2_def_id: DefId,
     ) -> Result<(), ErrorGuaranteed> {
-        let maybe_overlap = traits::overlapping_impls(
+        let maybe_overlap = traits::overlapping_inherent_impls(
             self.tcx,
             impl1_def_id,
             impl2_def_id,

compiler/rustc_trait_selection/src/traits/coherence.rs

@@ -100,7 +100,7 @@ impl TrackAmbiguityCauses {
 /// with a suitably-freshened `ImplHeader` with those types
 /// instantiated. Otherwise, returns `None`.
 #[instrument(skip(tcx, skip_leak_check), level = "debug")]
-pub fn overlapping_impls(
+pub fn overlapping_inherent_impls(
     tcx: TyCtxt<'_>,
     impl1_def_id: DefId,
     impl2_def_id: DefId,
@@ -110,32 +110,75 @@ pub fn overlapping_impls(
     // Before doing expensive operations like entering an inference context, do
     // a quick check via fast_reject to tell if the impl headers could possibly
     // unify.
-    let drcx = DeepRejectCtxt::relate_infer_infer(tcx);
-    let impl1_ref = tcx.impl_trait_ref(impl1_def_id);
-    let impl2_ref = tcx.impl_trait_ref(impl2_def_id);
-    let may_overlap = match (impl1_ref, impl2_ref) {
-        (Some(a), Some(b)) => drcx.args_may_unify(a.skip_binder().args, b.skip_binder().args),
-        (None, None) => {
-            let self_ty1 = tcx.type_of(impl1_def_id).skip_binder();
-            let self_ty2 = tcx.type_of(impl2_def_id).skip_binder();
-            drcx.types_may_unify(self_ty1, self_ty2)
-        }
-        _ => bug!("unexpected impls: {impl1_def_id:?} {impl2_def_id:?}"),
-    };
+    let self_ty1 = tcx.type_of(impl1_def_id).skip_binder();
+    let self_ty2 = tcx.type_of(impl2_def_id).skip_binder();
+    let may_overlap = DeepRejectCtxt::relate_infer_infer(tcx).types_may_unify(self_ty1, self_ty2);
+
+    if !may_overlap {
+        // Some types involved are definitely different, so the impls couldn't possibly overlap.
+        debug!("overlapping_inherent_impls: fast_reject early-exit");
+        return None;
+    }
+
+    overlapping_impls(tcx, impl1_def_id, None, impl2_def_id, None, skip_leak_check, overlap_mode)
+}
+
+/// If there are types that satisfy both impls, returns `Some`
+/// with a suitably-freshened `ImplHeader` with those types
+/// instantiated. Otherwise, returns `None`.
+#[instrument(skip(tcx, skip_leak_check), level = "debug")]
+pub fn overlapping_trait_impls(
+    tcx: TyCtxt<'_>,
+    impl1_def_id: DefId,
+    impl2_def_id: DefId,
+    skip_leak_check: SkipLeakCheck,
+    overlap_mode: OverlapMode,
+) -> Option<OverlapResult<'_>> {
+    // Before doing expensive operations like entering an inference context, do
+    // a quick check via fast_reject to tell if the impl headers could possibly
+    // unify.
+    let impl1_trait_ref = tcx.impl_trait_ref(impl1_def_id).unwrap();
+    let impl2_trait_ref = tcx.impl_trait_ref(impl2_def_id).unwrap();
+    let impl1_args = impl1_trait_ref.skip_binder().args;
+    let impl2_args = impl2_trait_ref.skip_binder().args;
+    let may_overlap =
+        DeepRejectCtxt::relate_infer_infer(tcx).args_may_unify(impl1_args, impl2_args);
 
     if !may_overlap {
         // Some types involved are definitely different, so the impls couldn't possibly overlap.
         debug!("overlapping_impls: fast_reject early-exit");
         return None;
     }
 
+    overlapping_impls(
+        tcx,
+        impl1_def_id,
+        Some(impl1_trait_ref),
+        impl2_def_id,
+        Some(impl2_trait_ref),
+        skip_leak_check,
+        overlap_mode,
+    )
+}
+
+fn overlapping_impls<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    impl1_def_id: DefId,
+    impl1_trait_ref: Option<ty::EarlyBinder<'tcx, ty::TraitRef<'tcx>>>,
+    impl2_def_id: DefId,
+    impl2_trait_ref: Option<ty::EarlyBinder<'tcx, ty::TraitRef<'tcx>>>,
+    skip_leak_check: SkipLeakCheck,
+    overlap_mode: OverlapMode,
+) -> Option<OverlapResult<'tcx>> {
     if tcx.next_trait_solver_in_coherence() {
         overlap(
             tcx,
             TrackAmbiguityCauses::Yes,
             skip_leak_check,
             impl1_def_id,
+            impl1_trait_ref,
             impl2_def_id,
+            impl2_trait_ref,
             overlap_mode,
         )
     } else {
@@ -144,7 +187,9 @@ pub fn overlapping_impls(
             TrackAmbiguityCauses::No,
             skip_leak_check,
             impl1_def_id,
+            impl1_trait_ref,
             impl2_def_id,
+            impl2_trait_ref,
             overlap_mode,
         )?;
 
@@ -156,23 +201,29 @@ pub fn overlapping_impls(
             TrackAmbiguityCauses::Yes,
             skip_leak_check,
             impl1_def_id,
+            impl1_trait_ref,
             impl2_def_id,
+            impl2_trait_ref,
             overlap_mode,
         )
         .unwrap();
         Some(overlap)
     }
 }
 
-fn fresh_impl_header<'tcx>(infcx: &InferCtxt<'tcx>, impl_def_id: DefId) -> ImplHeader<'tcx> {
+fn fresh_impl_header<'tcx>(
+    infcx: &InferCtxt<'tcx>,
+    impl_def_id: DefId,
+    trait_ref: Option<ty::EarlyBinder<'tcx, ty::TraitRef<'tcx>>>,
+) -> ImplHeader<'tcx> {
     let tcx = infcx.tcx;
     let impl_args = infcx.fresh_args_for_item(DUMMY_SP, impl_def_id);
 
     ImplHeader {
         impl_def_id,
         impl_args,
         self_ty: tcx.type_of(impl_def_id).instantiate(tcx, impl_args),
-        trait_ref: tcx.impl_trait_ref(impl_def_id).map(|i| i.instantiate(tcx, impl_args)),
+        trait_ref: trait_ref.map(|trait_ref| trait_ref.instantiate(tcx, impl_args)),
         predicates: tcx
             .predicates_of(impl_def_id)
             .instantiate(tcx, impl_args)
@@ -186,8 +237,9 @@ fn fresh_impl_header_normalized<'tcx>(
     infcx: &InferCtxt<'tcx>,
     param_env: ty::ParamEnv<'tcx>,
     impl_def_id: DefId,
+    trait_ref: Option<ty::EarlyBinder<'tcx, ty::TraitRef<'tcx>>>,
 ) -> ImplHeader<'tcx> {
-    let header = fresh_impl_header(infcx, impl_def_id);
+    let header = fresh_impl_header(infcx, impl_def_id, trait_ref);
 
     let InferOk { value: mut header, obligations } =
         infcx.at(&ObligationCause::dummy(), param_env).normalize(header);
@@ -204,13 +256,25 @@ fn overlap<'tcx>(
     track_ambiguity_causes: TrackAmbiguityCauses,
     skip_leak_check: SkipLeakCheck,
     impl1_def_id: DefId,
+    impl1_trait_ref: Option<ty::EarlyBinder<'tcx, ty::TraitRef<'tcx>>>,
     impl2_def_id: DefId,
+    impl2_trait_ref: Option<ty::EarlyBinder<'tcx, ty::TraitRef<'tcx>>>,
     overlap_mode: OverlapMode,
 ) -> Option<OverlapResult<'tcx>> {
     if overlap_mode.use_negative_impl() {
-        if impl_intersection_has_negative_obligation(tcx, impl1_def_id, impl2_def_id)
-            || impl_intersection_has_negative_obligation(tcx, impl2_def_id, impl1_def_id)
-        {
+        if impl_intersection_has_negative_obligation(
+            tcx,
+            impl1_def_id,
+            impl1_trait_ref,
+            impl2_def_id,
+            impl2_trait_ref,
+        ) || impl_intersection_has_negative_obligation(
+            tcx,
+            impl2_def_id,
+            impl2_trait_ref,
+            impl1_def_id,
+            impl1_trait_ref,
+        ) {
             return None;
         }
     }
@@ -231,8 +295,10 @@ fn overlap<'tcx>(
     // empty environment.
     let param_env = ty::ParamEnv::empty();
 
-    let impl1_header = fresh_impl_header_normalized(selcx.infcx, param_env, impl1_def_id);
-    let impl2_header = fresh_impl_header_normalized(selcx.infcx, param_env, impl2_def_id);
+    let impl1_header =
+        fresh_impl_header_normalized(selcx.infcx, param_env, impl1_def_id, impl1_trait_ref);
+    let impl2_header =
+        fresh_impl_header_normalized(selcx.infcx, param_env, impl2_def_id, impl2_trait_ref);
 
     // Equate the headers to find their intersection (the general type, with infer vars,
     // that may apply both impls).
@@ -442,10 +508,12 @@ fn impl_intersection_has_impossible_obligation<'a, 'cx, 'tcx>(
 /// after negating, giving us `&str: !Error`. This is a negative impl provided by
 /// libstd, and therefore we can guarantee for certain that libstd will never add
 /// a positive impl for `&str: Error` (without it being a breaking change).
-fn impl_intersection_has_negative_obligation(
-    tcx: TyCtxt<'_>,
+fn impl_intersection_has_negative_obligation<'tcx>(
+    tcx: TyCtxt<'tcx>,
     impl1_def_id: DefId,
+    impl1_trait_ref: Option<ty::EarlyBinder<'tcx, ty::TraitRef<'tcx>>>,
     impl2_def_id: DefId,
+    impl2_trait_ref: Option<ty::EarlyBinder<'tcx, ty::TraitRef<'tcx>>>,
 ) -> bool {
     debug!("negative_impl(impl1_def_id={:?}, impl2_def_id={:?})", impl1_def_id, impl2_def_id);
 
@@ -455,11 +523,11 @@ fn impl_intersection_has_negative_obligation(
     let root_universe = infcx.universe();
     assert_eq!(root_universe, ty::UniverseIndex::ROOT);
 
-    let impl1_header = fresh_impl_header(infcx, impl1_def_id);
+    let impl1_header = fresh_impl_header(infcx, impl1_def_id, impl1_trait_ref);
     let param_env =
         ty::EarlyBinder::bind(tcx.param_env(impl1_def_id)).instantiate(tcx, impl1_header.impl_args);
 
-    let impl2_header = fresh_impl_header(infcx, impl2_def_id);
+    let impl2_header = fresh_impl_header(infcx, impl2_def_id, impl2_trait_ref);
 
     // Equate the headers to find their intersection (the general type, with infer vars,
     // that may apply both impls).

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -42,7 +42,8 @@ use tracing::{debug, instrument};
 
 pub use self::coherence::{
     InCrate, IsFirstInputType, OrphanCheckErr, OrphanCheckMode, OverlapResult, UncoveredTyParams,
-    add_placeholder_note, orphan_check_trait_ref, overlapping_impls,
+    add_placeholder_note, orphan_check_trait_ref, overlapping_inherent_impls,
+    overlapping_trait_impls,
 };
 pub use self::dyn_compatibility::{
     DynCompatibilityViolation, dyn_compatibility_violations_for_assoc_item,

compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs

@@ -113,7 +113,7 @@ impl<'tcx> Children {
                 // Found overlap, but no specialization; error out or report future-compat warning.
 
                 // Do we *still* get overlap if we disable the future-incompatible modes?
-                let should_err = traits::overlapping_impls(
+                let should_err = traits::overlapping_trait_impls(
                     tcx,
                     possible_sibling,
                     impl_def_id,
@@ -137,7 +137,7 @@ impl<'tcx> Children {
             };
 
             let last_lint_mut = &mut last_lint;
-            let (le, ge) = traits::overlapping_impls(
+            let (le, ge) = traits::overlapping_trait_impls(
                 tcx,
                 possible_sibling,
                 impl_def_id,