Make DeepRejectCtxt symmetric with respect to TreatParams

Bryanskiy · Bryanskiy · commit 6738c1ec14f0 · 2024-08-14T20:27:30.000+03:00
diff --git a/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs b/compiler/rustc_hir_analysis/src/coherence/inherent_impls.rs
@@ -90,7 +90,8 @@ impl<'tcx> InherentCollect<'tcx> {
                 }
             }
 
-            if let Some(simp) = simplify_type(self.tcx, self_ty, TreatParams::AsCandidateKey) {
+            if let Some(simp) = simplify_type(self.tcx, self_ty, TreatParams::InstantiateWithInfer)
+            {
                 self.impls_map.incoherent_impls.entry(simp).or_default().push(impl_def_id);
             } else {
                 bug!("unexpected self type: {:?}", self_ty);
@@ -129,7 +130,7 @@ impl<'tcx> InherentCollect<'tcx> {
             }
         }
 
-        if let Some(simp) = simplify_type(self.tcx, ty, TreatParams::AsCandidateKey) {
+        if let Some(simp) = simplify_type(self.tcx, ty, TreatParams::InstantiateWithInfer) {
             self.impls_map.incoherent_impls.entry(simp).or_default().push(impl_def_id);
         } else {
             bug!("unexpected primitive type: {:?}", ty);
diff --git a/compiler/rustc_hir_typeck/src/method/probe.rs b/compiler/rustc_hir_typeck/src/method/probe.rs
@@ -714,7 +714,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
     }
 
     fn assemble_inherent_candidates_for_incoherent_ty(&mut self, self_ty: Ty<'tcx>) {
-        let Some(simp) = simplify_type(self.tcx, self_ty, TreatParams::AsCandidateKey) else {
+        let Some(simp) = simplify_type(self.tcx, self_ty, TreatParams::InstantiateWithInfer) else {
             bug!("unexpected incoherent type: {:?}", self_ty)
         };
         for &impl_def_id in self.tcx.incoherent_impls(simp).into_iter().flatten() {
diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -2234,8 +2234,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             let target_ty = self
                 .autoderef(sugg_span, rcvr_ty)
                 .find(|(rcvr_ty, _)| {
-                    DeepRejectCtxt::new(self.tcx, TreatParams::ForLookup)
-                        .types_may_unify(*rcvr_ty, impl_ty)
+                    DeepRejectCtxt::new(
+                        self.tcx,
+                        TreatParams::AsRigid,
+                        TreatParams::InstantiateWithInfer,
+                    )
+                    .types_may_unify(*rcvr_ty, impl_ty)
                 })
                 .map_or(impl_ty, |(ty, _)| ty)
                 .peel_refs();
@@ -2497,7 +2501,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             .into_iter()
             .any(|info| self.associated_value(info.def_id, item_name).is_some());
         let found_assoc = |ty: Ty<'tcx>| {
-            simplify_type(tcx, ty, TreatParams::AsCandidateKey)
+            simplify_type(tcx, ty, TreatParams::InstantiateWithInfer)
                 .and_then(|simp| {
                     tcx.incoherent_impls(simp)
                         .into_iter()
@@ -3927,7 +3931,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 // cases where a positive bound implies a negative impl.
                 (candidates, Vec::new())
             } else if let Some(simp_rcvr_ty) =
-                simplify_type(self.tcx, rcvr_ty, TreatParams::ForLookup)
+                simplify_type(self.tcx, rcvr_ty, TreatParams::AsRigid)
             {
                 let mut potential_candidates = Vec::new();
                 let mut explicitly_negative = Vec::new();
@@ -3945,7 +3949,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         .any(|header| {
                             let imp = header.trait_ref.instantiate_identity();
                             let imp_simp =
-                                simplify_type(self.tcx, imp.self_ty(), TreatParams::ForLookup);
+                                simplify_type(self.tcx, imp.self_ty(), TreatParams::AsRigid);
                             imp_simp.is_some_and(|s| s == simp_rcvr_ty)
                         })
                     {
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -2017,7 +2017,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 let simplified_self_ty = fast_reject::simplify_type(
                     self.tcx,
                     trait_ref.self_ty(),
-                    TreatParams::AsCandidateKey,
+                    TreatParams::InstantiateWithInfer,
                 );
                 trait_impls
                     .entry(trait_ref.def_id)
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
@@ -437,7 +437,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
                 let simp = ty::fast_reject::simplify_type(
                     tcx,
                     self_ty,
-                    ty::fast_reject::TreatParams::ForLookup,
+                    ty::fast_reject::TreatParams::AsRigid,
                 )
                 .unwrap();
                 consider_impls_for_simplified_type(simp);
diff --git a/compiler/rustc_middle/src/ty/trait_def.rs b/compiler/rustc_middle/src/ty/trait_def.rs
@@ -168,9 +168,9 @@ impl<'tcx> TyCtxt<'tcx> {
         // whose outer level is not a parameter or projection. Especially for things like
         // `T: Clone` this is incredibly useful as we would otherwise look at all the impls
         // of `Clone` for `Option<T>`, `Vec<T>`, `ConcreteType` and so on.
-        // Note that we're using `TreatParams::ForLookup` to query `non_blanket_impls` while using
-        // `TreatParams::AsCandidateKey` while actually adding them.
-        if let Some(simp) = fast_reject::simplify_type(self, self_ty, TreatParams::ForLookup) {
+        // Note that we're using `TreatParams::AsRigid` to query `non_blanket_impls` while using
+        // `TreatParams::InstantiateWithInfer` while actually adding them.
+        if let Some(simp) = fast_reject::simplify_type(self, self_ty, TreatParams::AsRigid) {
             if let Some(impls) = impls.non_blanket_impls.get(&simp) {
                 for &impl_def_id in impls {
                     f(impl_def_id);
@@ -190,7 +190,9 @@ impl<'tcx> TyCtxt<'tcx> {
         self_ty: Ty<'tcx>,
     ) -> impl Iterator<Item = DefId> + 'tcx {
         let impls = self.trait_impls_of(trait_def_id);
-        if let Some(simp) = fast_reject::simplify_type(self, self_ty, TreatParams::AsCandidateKey) {
+        if let Some(simp) =
+            fast_reject::simplify_type(self, self_ty, TreatParams::InstantiateWithInfer)
+        {
             if let Some(impls) = impls.non_blanket_impls.get(&simp) {
                 return impls.iter().copied();
             }
@@ -239,7 +241,7 @@ pub(super) fn trait_impls_of_provider(tcx: TyCtxt<'_>, trait_id: DefId) -> Trait
         let impl_self_ty = tcx.type_of(impl_def_id).instantiate_identity();
 
         if let Some(simplified_self_ty) =
-            fast_reject::simplify_type(tcx, impl_self_ty, TreatParams::AsCandidateKey)
+            fast_reject::simplify_type(tcx, impl_self_ty, TreatParams::InstantiateWithInfer)
         {
             impls.non_blanket_impls.entry(simplified_self_ty).or_default().push(impl_def_id);
         } else {
diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
@@ -144,10 +144,12 @@ where
 
         let goal_trait_ref = goal.predicate.alias.trait_ref(cx);
         let impl_trait_ref = cx.impl_trait_ref(impl_def_id);
-        if !DeepRejectCtxt::new(ecx.cx(), TreatParams::ForLookup).args_may_unify(
-            goal.predicate.alias.trait_ref(cx).args,
-            impl_trait_ref.skip_binder().args,
-        ) {
+        if !DeepRejectCtxt::new(ecx.cx(), TreatParams::AsRigid, TreatParams::InstantiateWithInfer)
+            .args_may_unify(
+                goal.predicate.alias.trait_ref(cx).args,
+                impl_trait_ref.skip_binder().args,
+            )
+        {
             return Err(NoSolution);
         }
 
diff --git a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
@@ -47,7 +47,7 @@ where
         let cx = ecx.cx();
 
         let impl_trait_ref = cx.impl_trait_ref(impl_def_id);
-        if !DeepRejectCtxt::new(ecx.cx(), TreatParams::ForLookup)
+        if !DeepRejectCtxt::new(ecx.cx(), TreatParams::AsRigid, TreatParams::InstantiateWithInfer)
             .args_may_unify(goal.predicate.trait_ref.args, impl_trait_ref.skip_binder().args)
         {
             return Err(NoSolution);
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
@@ -316,8 +316,12 @@ impl<T> Trait<T> for X {
                     {
                         let mut has_matching_impl = false;
                         tcx.for_each_relevant_impl(def_id, values.found, |did| {
-                            if DeepRejectCtxt::new(tcx, TreatParams::ForLookup)
-                                .types_may_unify(values.found, tcx.type_of(did).skip_binder())
+                            if DeepRejectCtxt::new(
+                                tcx,
+                                TreatParams::AsRigid,
+                                TreatParams::InstantiateWithInfer,
+                            )
+                            .types_may_unify(values.found, tcx.type_of(did).skip_binder())
                             {
                                 has_matching_impl = true;
                             }
@@ -337,8 +341,12 @@ impl<T> Trait<T> for X {
                     {
                         let mut has_matching_impl = false;
                         tcx.for_each_relevant_impl(def_id, values.expected, |did| {
-                            if DeepRejectCtxt::new(tcx, TreatParams::ForLookup)
-                                .types_may_unify(values.expected, tcx.type_of(did).skip_binder())
+                            if DeepRejectCtxt::new(
+                                tcx,
+                                TreatParams::AsRigid,
+                                TreatParams::InstantiateWithInfer,
+                            )
+                            .types_may_unify(values.expected, tcx.type_of(did).skip_binder())
                             {
                                 has_matching_impl = true;
                             }
@@ -357,8 +365,12 @@ impl<T> Trait<T> for X {
                     {
                         let mut has_matching_impl = false;
                         tcx.for_each_relevant_impl(def_id, values.found, |did| {
-                            if DeepRejectCtxt::new(tcx, TreatParams::ForLookup)
-                                .types_may_unify(values.found, tcx.type_of(did).skip_binder())
+                            if DeepRejectCtxt::new(
+                                tcx,
+                                TreatParams::AsRigid,
+                                TreatParams::InstantiateWithInfer,
+                            )
+                            .types_may_unify(values.found, tcx.type_of(did).skip_binder())
                             {
                                 has_matching_impl = true;
                             }
diff --git a/compiler/rustc_trait_selection/src/traits/coherence.rs b/compiler/rustc_trait_selection/src/traits/coherence.rs
@@ -94,7 +94,11 @@ 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::new(tcx, TreatParams::AsCandidateKey);
+    let drcx = DeepRejectCtxt::new(
+        tcx,
+        TreatParams::InstantiateWithInfer,
+        TreatParams::InstantiateWithInfer,
+    );
     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) {
diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -580,7 +580,11 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             return;
         }
 
-        let drcx = DeepRejectCtxt::new(self.tcx(), TreatParams::ForLookup);
+        let drcx = DeepRejectCtxt::new(
+            self.tcx(),
+            TreatParams::AsRigid,
+            TreatParams::InstantiateWithInfer,
+        );
         let obligation_args = obligation.predicate.skip_binder().trait_ref.args;
         self.tcx().for_each_relevant_impl(
             obligation.predicate.def_id(),
diff --git a/compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs b/compiler/rustc_trait_selection/src/traits/specialize/specialization_graph.rs
@@ -40,7 +40,7 @@ impl<'tcx> Children {
     fn insert_blindly(&mut self, tcx: TyCtxt<'tcx>, impl_def_id: DefId) {
         let trait_ref = tcx.impl_trait_ref(impl_def_id).unwrap().skip_binder();
         if let Some(st) =
-            fast_reject::simplify_type(tcx, trait_ref.self_ty(), TreatParams::AsCandidateKey)
+            fast_reject::simplify_type(tcx, trait_ref.self_ty(), TreatParams::InstantiateWithInfer)
         {
             debug!("insert_blindly: impl_def_id={:?} st={:?}", impl_def_id, st);
             self.non_blanket_impls.entry(st).or_default().push(impl_def_id)
@@ -57,7 +57,7 @@ impl<'tcx> Children {
         let trait_ref = tcx.impl_trait_ref(impl_def_id).unwrap().skip_binder();
         let vec: &mut Vec<DefId>;
         if let Some(st) =
-            fast_reject::simplify_type(tcx, trait_ref.self_ty(), TreatParams::AsCandidateKey)
+            fast_reject::simplify_type(tcx, trait_ref.self_ty(), TreatParams::InstantiateWithInfer)
         {
             debug!("remove_existing: impl_def_id={:?} st={:?}", impl_def_id, st);
             vec = self.non_blanket_impls.get_mut(&st).unwrap();
@@ -278,7 +278,7 @@ impl<'tcx> Graph {
         let mut parent = trait_def_id;
         let mut last_lint = None;
         let simplified =
-            fast_reject::simplify_type(tcx, trait_ref.self_ty(), TreatParams::AsCandidateKey);
+            fast_reject::simplify_type(tcx, trait_ref.self_ty(), TreatParams::InstantiateWithInfer);
 
         // Descend the specialization tree, where `parent` is the current parent node.
         loop {
diff --git a/compiler/rustc_type_ir/src/fast_reject.rs b/compiler/rustc_type_ir/src/fast_reject.rs
diff --git a/src/librustdoc/html/render/write_shared.rs b/src/librustdoc/html/render/write_shared.rs

Original file line number	Diff line number	Diff line change
`@@ -90,7 +90,8 @@ impl<'tcx> InherentCollect<'tcx> {`
`90`	`90`	`}`
`91`	`91`	`}`
`92`	`92`
`93`		`- if let Some(simp) = simplify_type(self.tcx, self_ty, TreatParams::AsCandidateKey) {`
	`93`	`+ if let Some(simp) = simplify_type(self.tcx, self_ty, TreatParams::InstantiateWithInfer)`
	`94`	`+ {`
`94`	`95`	`self.impls_map.incoherent_impls.entry(simp).or_default().push(impl_def_id);`
`95`	`96`	`} else {`
`96`	`97`	`bug!("unexpected self type: {:?}", self_ty);`
`@@ -129,7 +130,7 @@ impl<'tcx> InherentCollect<'tcx> {`
`129`	`130`	`}`
`130`	`131`	`}`
`131`	`132`
`132`		`- if let Some(simp) = simplify_type(self.tcx, ty, TreatParams::AsCandidateKey) {`
	`133`	`+ if let Some(simp) = simplify_type(self.tcx, ty, TreatParams::InstantiateWithInfer) {`
`133`	`134`	`self.impls_map.incoherent_impls.entry(simp).or_default().push(impl_def_id);`
`134`	`135`	`} else {`
`135`	`136`	`bug!("unexpected primitive type: {:?}", ty);`
Original file line number	Diff line number	Diff line change
`@@ -714,7 +714,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {`
`714`	`714`	`}`
`715`	`715`
`716`	`716`	`fn assemble_inherent_candidates_for_incoherent_ty(&mut self, self_ty: Ty<'tcx>) {`
`717`		`- let Some(simp) = simplify_type(self.tcx, self_ty, TreatParams::AsCandidateKey) else {`
	`717`	`+ let Some(simp) = simplify_type(self.tcx, self_ty, TreatParams::InstantiateWithInfer) else {`
`718`	`718`	`bug!("unexpected incoherent type: {:?}", self_ty)`
`719`	`719`	`};`
`720`	`720`	`for &impl_def_id in self.tcx.incoherent_impls(simp).into_iter().flatten() {`
Original file line number	Diff line number	Diff line change
`@@ -437,7 +437,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {`
`437`	`437`	`let simp = ty::fast_reject::simplify_type(`
`438`	`438`	`tcx,`
`439`	`439`	`self_ty,`
`440`		`- ty::fast_reject::TreatParams::ForLookup,`
	`440`	`+ ty::fast_reject::TreatParams::AsRigid,`
`441`	`441`	`)`
`442`	`442`	`.unwrap();`
`443`	`443`	`consider_impls_for_simplified_type(simp);`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ where`
`47`	`47`	`let cx = ecx.cx();`
`48`	`48`
`49`	`49`	`let impl_trait_ref = cx.impl_trait_ref(impl_def_id);`
`50`		`- if !DeepRejectCtxt::new(ecx.cx(), TreatParams::ForLookup)`
	`50`	`+ if !DeepRejectCtxt::new(ecx.cx(), TreatParams::AsRigid, TreatParams::InstantiateWithInfer)`
`51`	`51`	`.args_may_unify(goal.predicate.trait_ref.args, impl_trait_ref.skip_binder().args)`
`52`	`52`	`{`
`53`	`53`	`return Err(NoSolution);`
Original file line number	Diff line number	Diff line change
`@@ -316,8 +316,12 @@ impl<T> Trait<T> for X {`
`316`	`316`	`{`
`317`	`317`	`let mut has_matching_impl = false;`
`318`	`318`	`tcx.for_each_relevant_impl(def_id, values.found, \|did\| {`
`319`		`- if DeepRejectCtxt::new(tcx, TreatParams::ForLookup)`
`320`		`- .types_may_unify(values.found, tcx.type_of(did).skip_binder())`
	`319`	`+ if DeepRejectCtxt::new(`
	`320`	`+ tcx,`
	`321`	`+ TreatParams::AsRigid,`
	`322`	`+ TreatParams::InstantiateWithInfer,`
	`323`	`+ )`
	`324`	`+ .types_may_unify(values.found, tcx.type_of(did).skip_binder())`
`321`	`325`	`{`
`322`	`326`	`has_matching_impl = true;`
`323`	`327`	`}`
`@@ -337,8 +341,12 @@ impl<T> Trait<T> for X {`
`337`	`341`	`{`
`338`	`342`	`let mut has_matching_impl = false;`
`339`	`343`	`tcx.for_each_relevant_impl(def_id, values.expected, \|did\| {`
`340`		`- if DeepRejectCtxt::new(tcx, TreatParams::ForLookup)`
`341`		`- .types_may_unify(values.expected, tcx.type_of(did).skip_binder())`
	`344`	`+ if DeepRejectCtxt::new(`
	`345`	`+ tcx,`
	`346`	`+ TreatParams::AsRigid,`
	`347`	`+ TreatParams::InstantiateWithInfer,`
	`348`	`+ )`
	`349`	`+ .types_may_unify(values.expected, tcx.type_of(did).skip_binder())`
`342`	`350`	`{`
`343`	`351`	`has_matching_impl = true;`
`344`	`352`	`}`
`@@ -357,8 +365,12 @@ impl<T> Trait<T> for X {`
`357`	`365`	`{`
`358`	`366`	`let mut has_matching_impl = false;`
`359`	`367`	`tcx.for_each_relevant_impl(def_id, values.found, \|did\| {`
`360`		`- if DeepRejectCtxt::new(tcx, TreatParams::ForLookup)`
`361`		`- .types_may_unify(values.found, tcx.type_of(did).skip_binder())`
	`368`	`+ if DeepRejectCtxt::new(`
	`369`	`+ tcx,`
	`370`	`+ TreatParams::AsRigid,`
	`371`	`+ TreatParams::InstantiateWithInfer,`
	`372`	`+ )`
	`373`	`+ .types_may_unify(values.found, tcx.type_of(did).skip_binder())`
`362`	`374`	`{`
`363`	`375`	`has_matching_impl = true;`
`364`	`376`	`}`