From f6f439668ae3b9976c6eae8494e24b1e89492c5e Mon Sep 17 00:00:00 2001 From: lcnr Date: Fri, 29 Nov 2024 10:49:11 +0100 Subject: [PATCH] fast_reject: add cache --- .../src/traits/coherence.rs | 2 +- .../src/traits/effects.rs | 2 +- .../src/traits/project.rs | 2 +- .../src/traits/select/candidate_assembly.rs | 4 +-- compiler/rustc_type_ir/src/fast_reject.rs | 32 +++++++++++++------ src/librustdoc/html/render/write_shared.rs | 4 +-- 6 files changed, 30 insertions(+), 16 deletions(-) diff --git a/compiler/rustc_trait_selection/src/traits/coherence.rs b/compiler/rustc_trait_selection/src/traits/coherence.rs index a98871b2d60a4..af65a4741b739 100644 --- a/compiler/rustc_trait_selection/src/traits/coherence.rs +++ b/compiler/rustc_trait_selection/src/traits/coherence.rs @@ -98,7 +98,7 @@ 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 mut 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) { diff --git a/compiler/rustc_trait_selection/src/traits/effects.rs b/compiler/rustc_trait_selection/src/traits/effects.rs index 07fb2efb7fed3..e1f1cb27c3618 100644 --- a/compiler/rustc_trait_selection/src/traits/effects.rs +++ b/compiler/rustc_trait_selection/src/traits/effects.rs @@ -79,7 +79,7 @@ fn evaluate_host_effect_from_bounds<'tcx>( obligation: &HostEffectObligation<'tcx>, ) -> Result>, EvaluationFailure> { let infcx = selcx.infcx; - let drcx = DeepRejectCtxt::relate_rigid_rigid(selcx.tcx()); + let mut drcx = DeepRejectCtxt::relate_rigid_rigid(selcx.tcx()); let mut candidate = None; for predicate in obligation.param_env.caller_bounds() { diff --git a/compiler/rustc_trait_selection/src/traits/project.rs b/compiler/rustc_trait_selection/src/traits/project.rs index 2864f277df578..d305d81b6414f 100644 --- a/compiler/rustc_trait_selection/src/traits/project.rs +++ b/compiler/rustc_trait_selection/src/traits/project.rs @@ -866,7 +866,7 @@ fn assemble_candidates_from_predicates<'cx, 'tcx>( potentially_unnormalized_candidates: bool, ) { let infcx = selcx.infcx; - let drcx = DeepRejectCtxt::relate_rigid_rigid(selcx.tcx()); + let mut drcx = DeepRejectCtxt::relate_rigid_rigid(selcx.tcx()); for predicate in env_predicates { let bound_predicate = predicate.kind(); if let ty::ClauseKind::Projection(data) = predicate.kind().skip_binder() { diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs index 32b4567aba4f0..8503af4fbd219 100644 --- a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs +++ b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs @@ -232,7 +232,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { .filter(|p| p.def_id() == stack.obligation.predicate.def_id()) .filter(|p| p.polarity() == stack.obligation.predicate.polarity()); - let drcx = DeepRejectCtxt::relate_rigid_rigid(self.tcx()); + let mut drcx = DeepRejectCtxt::relate_rigid_rigid(self.tcx()); let obligation_args = stack.obligation.predicate.skip_binder().trait_ref.args; // Keep only those bounds which may apply, and propagate overflow if it occurs. for bound in bounds { @@ -548,7 +548,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> { obligation: &PolyTraitObligation<'tcx>, candidates: &mut SelectionCandidateSet<'tcx>, ) { - let drcx = DeepRejectCtxt::relate_rigid_infer(self.tcx()); + let mut drcx = DeepRejectCtxt::relate_rigid_infer(self.tcx()); 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_type_ir/src/fast_reject.rs b/compiler/rustc_type_ir/src/fast_reject.rs index 2c8e47bcbca2a..b8bb927b73026 100644 --- a/compiler/rustc_type_ir/src/fast_reject.rs +++ b/compiler/rustc_type_ir/src/fast_reject.rs @@ -11,6 +11,7 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHas #[cfg(feature = "nightly")] use rustc_macros::{HashStable_NoContext, TyDecodable, TyEncodable}; +use crate::data_structures::DelayedSet; use crate::inherent::*; use crate::visit::TypeVisitableExt as _; use crate::{self as ty, Interner}; @@ -181,33 +182,36 @@ impl SimplifiedType { /// We also use this function during coherence. For coherence the /// impls only have to overlap for some value, so we treat parameters /// on both sides like inference variables. -#[derive(Debug, Clone, Copy)] +#[derive(Debug)] pub struct DeepRejectCtxt< I: Interner, const INSTANTIATE_LHS_WITH_INFER: bool, const INSTANTIATE_RHS_WITH_INFER: bool, > { _interner: PhantomData, + /// We use a cache here as exponentially large - but self-similar - types otherwise + /// cause hangs, e.g. when compiling itertools with the `-Znext-solver`. + cache: DelayedSet<(I::Ty, I::Ty)>, } impl DeepRejectCtxt { /// Treat parameters in both the lhs and the rhs as rigid. pub fn relate_rigid_rigid(_interner: I) -> DeepRejectCtxt { - DeepRejectCtxt { _interner: PhantomData } + DeepRejectCtxt { _interner: PhantomData, cache: Default::default() } } } impl DeepRejectCtxt { /// Treat parameters in both the lhs and the rhs as infer vars. pub fn relate_infer_infer(_interner: I) -> DeepRejectCtxt { - DeepRejectCtxt { _interner: PhantomData } + DeepRejectCtxt { _interner: PhantomData, cache: Default::default() } } } impl DeepRejectCtxt { /// Treat parameters in the lhs as rigid, and in rhs as infer vars. pub fn relate_rigid_infer(_interner: I) -> DeepRejectCtxt { - DeepRejectCtxt { _interner: PhantomData } + DeepRejectCtxt { _interner: PhantomData, cache: Default::default() } } } @@ -215,7 +219,7 @@ impl { pub fn args_may_unify( - self, + &mut self, obligation_args: I::GenericArgs, impl_args: I::GenericArgs, ) -> bool { @@ -234,7 +238,7 @@ impl bool { + pub fn types_may_unify(&mut self, lhs: I::Ty, rhs: I::Ty) -> bool { match rhs.kind() { // Start by checking whether the `rhs` type may unify with // pretty much everything. Just return `true` in that case. @@ -273,8 +277,12 @@ impl {} }; + if self.cache.contains(&(lhs, rhs)) { + return true; + } + // For purely rigid types, use structural equivalence. - match lhs.kind() { + let result = match lhs.kind() { ty::Ref(_, lhs_ty, lhs_mutbl) => match rhs.kind() { ty::Ref(_, rhs_ty, rhs_mutbl) => { lhs_mutbl == rhs_mutbl && self.types_may_unify(lhs_ty, rhs_ty) @@ -414,10 +422,16 @@ impl true, + }; + + if result { + self.cache.insert((lhs, rhs)); } + + result } - pub fn consts_may_unify(self, lhs: I::Const, rhs: I::Const) -> bool { + pub fn consts_may_unify(&mut self, lhs: I::Const, rhs: I::Const) -> bool { match rhs.kind() { ty::ConstKind::Param(_) => { if INSTANTIATE_RHS_WITH_INFER { @@ -465,7 +479,7 @@ impl bool { + fn var_and_ty_may_unify(&mut self, var: ty::InferTy, ty: I::Ty) -> bool { if !ty.is_known_rigid() { return true; } diff --git a/src/librustdoc/html/render/write_shared.rs b/src/librustdoc/html/render/write_shared.rs index 7c676469597dc..088de5668ed53 100644 --- a/src/librustdoc/html/render/write_shared.rs +++ b/src/librustdoc/html/render/write_shared.rs @@ -918,8 +918,8 @@ impl<'item> DocVisitor<'item> for TypeImplCollector<'_, '_, 'item> { // Be aware of `tests/rustdoc/type-alias/deeply-nested-112515.rs` which might regress. let Some(impl_did) = impl_item_id.as_def_id() else { continue }; let for_ty = self.cx.tcx().type_of(impl_did).skip_binder(); - let reject_cx = DeepRejectCtxt::relate_infer_infer(self.cx.tcx()); - if !reject_cx.types_may_unify(aliased_ty, for_ty) { + let mut drcx = DeepRejectCtxt::relate_infer_infer(self.cx.tcx()); + if !drcx.types_may_unify(aliased_ty, for_ty) { continue; } // Avoid duplicates