Pass TraitRefs to overlap

Author: camsteffen

compiler/rustc_trait_selection/src/traits/coherence.rs

@@ -120,7 +120,7 @@ pub fn overlapping_inherent_impls(
         return None;
     }
 
-    overlapping_impls(tcx, impl1_def_id, impl2_def_id, skip_leak_check, overlap_mode, false)
+    overlapping_impls(tcx, impl1_def_id, impl2_def_id, skip_leak_check, overlap_mode, None)
 }
 
 /// If there are types that satisfy both impls, returns `Some`
@@ -137,8 +137,10 @@ pub fn overlapping_trait_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 impl1_args = tcx.impl_trait_ref(impl1_def_id).unwrap().skip_binder().args;
-    let impl2_args = tcx.impl_trait_ref(impl2_def_id).unwrap().skip_binder().args;
+    let trait_ref1 = tcx.impl_trait_ref(impl1_def_id).unwrap();
+    let trait_ref2 = tcx.impl_trait_ref(impl2_def_id).unwrap();
+    let impl1_args = trait_ref1.skip_binder().args;
+    let impl2_args = trait_ref2.skip_binder().args;
     let may_overlap =
         DeepRejectCtxt::relate_infer_infer(tcx).args_may_unify(impl1_args, impl2_args);
 
@@ -148,17 +150,21 @@ pub fn overlapping_trait_impls(
         return None;
     }
 
-    overlapping_impls(tcx, impl1_def_id, impl2_def_id, skip_leak_check, overlap_mode, true)
+    let trait_refs = Some((trait_ref1, trait_ref2));
+    overlapping_impls(tcx, impl1_def_id, impl2_def_id, skip_leak_check, overlap_mode, trait_refs)
 }
 
-fn overlapping_impls(
-    tcx: TyCtxt<'_>,
+fn overlapping_impls<'tcx>(
+    tcx: TyCtxt<'tcx>,
     impl1_def_id: DefId,
     impl2_def_id: DefId,
     skip_leak_check: SkipLeakCheck,
     overlap_mode: OverlapMode,
-    is_of_trait: bool,
-) -> Option<OverlapResult<'_>> {
+    trait_refs: Option<(
+        ty::EarlyBinder<'tcx, ty::TraitRef<'tcx>>,
+        ty::EarlyBinder<'tcx, ty::TraitRef<'tcx>>,
+    )>,
+) -> Option<OverlapResult<'tcx>> {
     if tcx.next_trait_solver_in_coherence() {
         overlap(
             tcx,
@@ -167,7 +173,7 @@ fn overlapping_impls(
             impl1_def_id,
             impl2_def_id,
             overlap_mode,
-            is_of_trait,
+            trait_refs,
         )
     } else {
         let _overlap_with_bad_diagnostics = overlap(
@@ -177,7 +183,7 @@ fn overlapping_impls(
             impl1_def_id,
             impl2_def_id,
             overlap_mode,
-            is_of_trait,
+            trait_refs,
         )?;
 
         // In the case where we detect an error, run the check again, but
@@ -190,7 +196,7 @@ fn overlapping_impls(
             impl1_def_id,
             impl2_def_id,
             overlap_mode,
-            is_of_trait,
+            trait_refs,
         )
         .unwrap();
         Some(overlap)
@@ -200,7 +206,7 @@ fn overlapping_impls(
 fn fresh_impl_header<'tcx>(
     infcx: &InferCtxt<'tcx>,
     impl_def_id: DefId,
-    is_of_trait: bool,
+    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);
@@ -209,8 +215,7 @@ fn fresh_impl_header<'tcx>(
         impl_def_id,
         impl_args,
         self_ty: tcx.type_of(impl_def_id).instantiate(tcx, impl_args),
-        trait_ref: is_of_trait
-            .then(|| tcx.impl_trait_ref(impl_def_id).unwrap().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)
@@ -224,9 +229,9 @@ fn fresh_impl_header_normalized<'tcx>(
     infcx: &InferCtxt<'tcx>,
     param_env: ty::ParamEnv<'tcx>,
     impl_def_id: DefId,
-    is_of_trait: bool,
+    trait_ref: Option<ty::EarlyBinder<'tcx, ty::TraitRef<'tcx>>>,
 ) -> ImplHeader<'tcx> {
-    let header = fresh_impl_header(infcx, impl_def_id, is_of_trait);
+    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);
@@ -245,15 +250,18 @@ fn overlap<'tcx>(
     impl1_def_id: DefId,
     impl2_def_id: DefId,
     overlap_mode: OverlapMode,
-    is_of_trait: bool,
+    trait_refs: Option<(
+        ty::EarlyBinder<'tcx, ty::TraitRef<'tcx>>,
+        ty::EarlyBinder<'tcx, ty::TraitRef<'tcx>>,
+    )>,
 ) -> Option<OverlapResult<'tcx>> {
     if overlap_mode.use_negative_impl() {
-        if impl_intersection_has_negative_obligation(tcx, impl1_def_id, impl2_def_id, is_of_trait)
+        if impl_intersection_has_negative_obligation(tcx, impl1_def_id, impl2_def_id, trait_refs)
             || impl_intersection_has_negative_obligation(
                 tcx,
                 impl2_def_id,
                 impl1_def_id,
-                is_of_trait,
+                trait_refs,
             )
         {
             return None;
@@ -276,10 +284,11 @@ fn overlap<'tcx>(
     // empty environment.
     let param_env = ty::ParamEnv::empty();
 
+    let (trait_ref1, trait_ref2) = trait_refs.unzip();
     let impl1_header =
-        fresh_impl_header_normalized(selcx.infcx, param_env, impl1_def_id, is_of_trait);
+        fresh_impl_header_normalized(selcx.infcx, param_env, impl1_def_id, trait_ref1);
     let impl2_header =
-        fresh_impl_header_normalized(selcx.infcx, param_env, impl2_def_id, is_of_trait);
+        fresh_impl_header_normalized(selcx.infcx, param_env, impl2_def_id, trait_ref2);
 
     // Equate the headers to find their intersection (the general type, with infer vars,
     // that may apply both impls).
@@ -489,11 +498,14 @@ 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,
     impl2_def_id: DefId,
-    is_of_trait: bool,
+    trait_refs: Option<(
+        ty::EarlyBinder<'tcx, ty::TraitRef<'tcx>>,
+        ty::EarlyBinder<'tcx, ty::TraitRef<'tcx>>,
+    )>,
 ) -> bool {
     debug!("negative_impl(impl1_def_id={:?}, impl2_def_id={:?})", impl1_def_id, impl2_def_id);
 
@@ -503,11 +515,12 @@ 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, is_of_trait);
+    let (trait_ref1, trait_ref2) = trait_refs.unzip();
+    let impl1_header = fresh_impl_header(infcx, impl1_def_id, trait_ref1);
     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, is_of_trait);
+    let impl2_header = fresh_impl_header(infcx, impl2_def_id, trait_ref2);
 
     // Equate the headers to find their intersection (the general type, with infer vars,
     // that may apply both impls).