From db638ab968fe35ec6889e9fcf8fef1c4c623ac1d Mon Sep 17 00:00:00 2001 From: Michael Goulet Date: Tue, 18 Jun 2024 19:13:54 -0400 Subject: [PATCH] Rename a bunch of things --- .../rustc_borrowck/src/region_infer/mod.rs | 2 +- .../src/check/compare_impl_item.rs | 16 +- .../src/check/compare_impl_item/refine.rs | 2 +- .../src/coherence/orphan.rs | 2 +- .../src/collect/item_bounds.rs | 2 +- compiler/rustc_hir_typeck/src/writeback.rs | 2 +- .../src/infer/canonical/canonicalizer.rs | 4 +- .../infer/error_reporting/need_type_info.rs | 2 +- compiler/rustc_infer/src/infer/freshen.rs | 4 +- compiler/rustc_infer/src/infer/mod.rs | 4 +- compiler/rustc_infer/src/infer/resolve.rs | 8 +- .../rustc_infer/src/infer/snapshot/fudge.rs | 2 +- compiler/rustc_lint/src/non_local_def.rs | 2 +- compiler/rustc_middle/src/traits/solve.rs | 22 ++- .../rustc_middle/src/ty/abstract_const.rs | 2 +- compiler/rustc_middle/src/ty/diagnostics.rs | 2 +- compiler/rustc_middle/src/ty/erase_regions.rs | 2 +- compiler/rustc_middle/src/ty/fold.rs | 6 +- compiler/rustc_middle/src/ty/generic_args.rs | 6 +- compiler/rustc_middle/src/ty/instance.rs | 2 +- .../src/ty/normalize_erasing_regions.rs | 4 +- compiler/rustc_middle/src/ty/opaque_types.rs | 4 +- compiler/rustc_middle/src/ty/print/pretty.rs | 2 +- .../rustc_middle/src/ty/structural_impls.rs | 8 +- compiler/rustc_middle/src/ty/util.rs | 6 +- .../src/canonicalizer.rs | 48 +++--- .../src/{infcx.rs => delegate.rs} | 6 +- compiler/rustc_next_trait_solver/src/lib.rs | 2 +- .../rustc_next_trait_solver/src/resolve.rs | 32 ++-- .../src/solve/alias_relate.rs | 8 +- .../src/solve/assembly/mod.rs | 115 ++++++------- .../src/solve/assembly/structural_traits.rs | 58 +++---- .../src/solve/eval_ctxt/canonical.rs | 85 +++++----- .../src/solve/eval_ctxt/mod.rs | 156 +++++++++--------- .../src/solve/eval_ctxt/probe.rs | 49 +++--- .../src/solve/inspect/build.rs | 55 +++--- .../rustc_next_trait_solver/src/solve/mod.rs | 18 +- .../src/solve/normalizes_to/anon_const.rs | 6 +- .../src/solve/normalizes_to/inherent.rs | 8 +- .../src/solve/normalizes_to/mod.rs | 112 ++++++------- .../src/solve/normalizes_to/opaque_types.rs | 10 +- .../src/solve/normalizes_to/weak_types.rs | 8 +- .../src/solve/project_goals.rs | 8 +- .../src/solve/search_graph.rs | 20 +-- .../src/solve/trait_goals.rs | 116 ++++++------- .../cfi/typeid/itanium_cxx_abi/transform.rs | 2 +- compiler/rustc_trait_selection/src/solve.rs | 2 +- .../src/solve/{infcx.rs => delegate.rs} | 4 +- .../src/solve/fulfill.rs | 2 +- .../src/solve/inspect/analyse.rs | 2 +- .../src/solve/normalize.rs | 4 +- .../src/traits/error_reporting/suggestions.rs | 2 +- .../error_reporting/type_err_ctxt_ext.rs | 2 +- .../rustc_trait_selection/src/traits/mod.rs | 2 +- .../src/traits/normalize.rs | 10 +- .../src/traits/query/normalize.rs | 12 +- .../rustc_trait_selection/src/traits/util.rs | 6 +- compiler/rustc_type_ir/src/binder.rs | 4 +- compiler/rustc_type_ir/src/fold.rs | 10 +- compiler/rustc_type_ir/src/ty_kind/closure.rs | 2 +- 60 files changed, 538 insertions(+), 566 deletions(-) rename compiler/rustc_next_trait_solver/src/{infcx.rs => delegate.rs} (98%) rename compiler/rustc_trait_selection/src/solve/{infcx.rs => delegate.rs} (99%) diff --git a/compiler/rustc_borrowck/src/region_infer/mod.rs b/compiler/rustc_borrowck/src/region_infer/mod.rs index 40b5850059820..bf1c1b1433ea6 100644 --- a/compiler/rustc_borrowck/src/region_infer/mod.rs +++ b/compiler/rustc_borrowck/src/region_infer/mod.rs @@ -1110,7 +1110,7 @@ impl<'tcx> RegionInferenceContext<'tcx> { tcx: TyCtxt<'tcx>, } impl<'tcx> ty::TypeFolder> for OpaqueFolder<'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> { diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs index 82b57cdd10691..550f38af8b5da 100644 --- a/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs +++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs @@ -397,7 +397,7 @@ struct RemapLateBound<'a, 'tcx> { } impl<'tcx> TypeFolder> for RemapLateBound<'_, 'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } @@ -790,13 +790,13 @@ impl<'tcx, E> TypeFolder> for ImplTraitInTraitCollector<'_, 'tcx, E where E: 'tcx, { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.ocx.infcx.tcx } fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> { if let ty::Alias(ty::Projection, proj) = ty.kind() - && self.interner().is_impl_trait_in_trait(proj.def_id) + && self.cx().is_impl_trait_in_trait(proj.def_id) { if let Some((ty, _)) = self.types.get(&proj.def_id) { return *ty; @@ -810,9 +810,9 @@ where self.types.insert(proj.def_id, (infer_ty, proj.args)); // Recurse into bounds for (pred, pred_span) in self - .interner() + .cx() .explicit_item_bounds(proj.def_id) - .iter_instantiated_copied(self.interner(), proj.args) + .iter_instantiated_copied(self.cx(), proj.args) { let pred = pred.fold_with(self); let pred = self.ocx.normalize( @@ -822,7 +822,7 @@ where ); self.ocx.register_obligation(traits::Obligation::new( - self.interner(), + self.cx(), ObligationCause::new( self.span, self.body_id, @@ -853,7 +853,7 @@ struct RemapHiddenTyRegions<'tcx> { impl<'tcx> ty::FallibleTypeFolder> for RemapHiddenTyRegions<'tcx> { type Error = ErrorGuaranteed; - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } @@ -2072,7 +2072,7 @@ struct ReplaceTy<'tcx> { } impl<'tcx> TypeFolder> for ReplaceTy<'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } diff --git a/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs b/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs index 10b097a1060f3..6cdbd692f73be 100644 --- a/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs +++ b/compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs @@ -322,7 +322,7 @@ struct Anonymize<'tcx> { } impl<'tcx> TypeFolder> for Anonymize<'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } diff --git a/compiler/rustc_hir_analysis/src/coherence/orphan.rs b/compiler/rustc_hir_analysis/src/coherence/orphan.rs index 9421269e51ea6..5cb91603fd067 100644 --- a/compiler/rustc_hir_analysis/src/coherence/orphan.rs +++ b/compiler/rustc_hir_analysis/src/coherence/orphan.rs @@ -539,7 +539,7 @@ struct TyVarReplacer<'cx, 'tcx> { } impl<'cx, 'tcx> TypeFolder> for TyVarReplacer<'cx, 'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.infcx.tcx } diff --git a/compiler/rustc_hir_analysis/src/collect/item_bounds.rs b/compiler/rustc_hir_analysis/src/collect/item_bounds.rs index 94d6e13d751fc..9f198933dee4f 100644 --- a/compiler/rustc_hir_analysis/src/collect/item_bounds.rs +++ b/compiler/rustc_hir_analysis/src/collect/item_bounds.rs @@ -203,7 +203,7 @@ struct AssocTyToOpaque<'tcx> { } impl<'tcx> TypeFolder> for AssocTyToOpaque<'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } diff --git a/compiler/rustc_hir_typeck/src/writeback.rs b/compiler/rustc_hir_typeck/src/writeback.rs index 2714be1f9b4f3..aea0114167eb9 100644 --- a/compiler/rustc_hir_typeck/src/writeback.rs +++ b/compiler/rustc_hir_typeck/src/writeback.rs @@ -847,7 +847,7 @@ impl<'cx, 'tcx> Resolver<'cx, 'tcx> { } impl<'cx, 'tcx> TypeFolder> for Resolver<'cx, 'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.fcx.tcx } diff --git a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs index bc2592b43f3d3..1659f3d049370 100644 --- a/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs +++ b/compiler/rustc_infer/src/infer/canonical/canonicalizer.rs @@ -304,7 +304,7 @@ struct Canonicalizer<'cx, 'tcx> { } impl<'cx, 'tcx> TypeFolder> for Canonicalizer<'cx, 'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } @@ -773,7 +773,7 @@ impl<'cx, 'tcx> Canonicalizer<'cx, 'tcx> { ) -> ty::Region<'tcx> { let var = self.canonical_var(info, r.into()); let br = ty::BoundRegion { var, kind: ty::BrAnon }; - ty::Region::new_bound(self.interner(), self.binder_index, br) + ty::Region::new_bound(self.cx(), self.binder_index, br) } /// Given a type variable `ty_var` of the given kind, first check diff --git a/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs b/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs index cb0e13652e800..d7349abc44c24 100644 --- a/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs +++ b/compiler/rustc_infer/src/infer/error_reporting/need_type_info.rs @@ -158,7 +158,7 @@ struct ClosureEraser<'tcx> { } impl<'tcx> TypeFolder> for ClosureEraser<'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } diff --git a/compiler/rustc_infer/src/infer/freshen.rs b/compiler/rustc_infer/src/infer/freshen.rs index 50526c964edc4..de4267f7ceadd 100644 --- a/compiler/rustc_infer/src/infer/freshen.rs +++ b/compiler/rustc_infer/src/infer/freshen.rs @@ -101,7 +101,7 @@ impl<'a, 'tcx> TypeFreshener<'a, 'tcx> { } impl<'a, 'tcx> TypeFolder> for TypeFreshener<'a, 'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.infcx.tcx } @@ -118,7 +118,7 @@ impl<'a, 'tcx> TypeFolder> for TypeFreshener<'a, 'tcx> { | ty::RePlaceholder(..) | ty::ReStatic | ty::ReError(_) - | ty::ReErased => self.interner().lifetimes.re_erased, + | ty::ReErased => self.cx().lifetimes.re_erased, } } diff --git a/compiler/rustc_infer/src/infer/mod.rs b/compiler/rustc_infer/src/infer/mod.rs index 4d6ddd7ba66ab..a3cf588da1c02 100644 --- a/compiler/rustc_infer/src/infer/mod.rs +++ b/compiler/rustc_infer/src/infer/mod.rs @@ -1719,7 +1719,7 @@ struct InferenceLiteralEraser<'tcx> { } impl<'tcx> TypeFolder> for InferenceLiteralEraser<'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } @@ -1859,7 +1859,7 @@ fn replace_param_and_infer_args_with_placeholder<'tcx>( } impl<'tcx> TypeFolder> for ReplaceParamAndInferWithPlaceholder<'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } diff --git a/compiler/rustc_infer/src/infer/resolve.rs b/compiler/rustc_infer/src/infer/resolve.rs index 830d79f52b945..ed75fd183f29d 100644 --- a/compiler/rustc_infer/src/infer/resolve.rs +++ b/compiler/rustc_infer/src/infer/resolve.rs @@ -24,7 +24,7 @@ impl<'a, 'tcx> OpportunisticVarResolver<'a, 'tcx> { } impl<'a, 'tcx> TypeFolder> for OpportunisticVarResolver<'a, 'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.infcx.tcx } @@ -66,7 +66,7 @@ impl<'a, 'tcx> OpportunisticRegionResolver<'a, 'tcx> { } impl<'a, 'tcx> TypeFolder> for OpportunisticRegionResolver<'a, 'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.infcx.tcx } @@ -85,7 +85,7 @@ impl<'a, 'tcx> TypeFolder> for OpportunisticRegionResolver<'a, 'tcx .inner .borrow_mut() .unwrap_region_constraints() - .opportunistic_resolve_var(TypeFolder::interner(self), vid), + .opportunistic_resolve_var(TypeFolder::cx(self), vid), _ => r, } } @@ -121,7 +121,7 @@ struct FullTypeResolver<'a, 'tcx> { impl<'a, 'tcx> FallibleTypeFolder> for FullTypeResolver<'a, 'tcx> { type Error = FixupError; - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.infcx.tcx } diff --git a/compiler/rustc_infer/src/infer/snapshot/fudge.rs b/compiler/rustc_infer/src/infer/snapshot/fudge.rs index a086c82c92e8a..f15bd0babee5c 100644 --- a/compiler/rustc_infer/src/infer/snapshot/fudge.rs +++ b/compiler/rustc_infer/src/infer/snapshot/fudge.rs @@ -183,7 +183,7 @@ pub struct InferenceFudger<'a, 'tcx> { } impl<'a, 'tcx> TypeFolder> for InferenceFudger<'a, 'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.infcx.tcx } diff --git a/compiler/rustc_lint/src/non_local_def.rs b/compiler/rustc_lint/src/non_local_def.rs index 24dd337e69957..300dac442d564 100644 --- a/compiler/rustc_lint/src/non_local_def.rs +++ b/compiler/rustc_lint/src/non_local_def.rs @@ -390,7 +390,7 @@ struct ReplaceLocalTypesWithInfer<'a, 'tcx, F: FnMut(DefId) -> bool> { impl<'a, 'tcx, F: FnMut(DefId) -> bool> TypeFolder> for ReplaceLocalTypesWithInfer<'a, 'tcx, F> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.infcx.tcx } diff --git a/compiler/rustc_middle/src/traits/solve.rs b/compiler/rustc_middle/src/traits/solve.rs index 90f80f90767d9..7bc4c60f10272 100644 --- a/compiler/rustc_middle/src/traits/solve.rs +++ b/compiler/rustc_middle/src/traits/solve.rs @@ -53,7 +53,7 @@ impl<'tcx> TypeFoldable> for ExternalConstraints<'tcx> { self, folder: &mut F, ) -> Result { - Ok(FallibleTypeFolder::interner(folder).mk_external_constraints(ExternalConstraintsData { + Ok(FallibleTypeFolder::cx(folder).mk_external_constraints(ExternalConstraintsData { region_constraints: self.region_constraints.clone().try_fold_with(folder)?, opaque_types: self .opaque_types @@ -68,7 +68,7 @@ impl<'tcx> TypeFoldable> for ExternalConstraints<'tcx> { } fn fold_with>>(self, folder: &mut F) -> Self { - TypeFolder::interner(folder).mk_external_constraints(ExternalConstraintsData { + TypeFolder::cx(folder).mk_external_constraints(ExternalConstraintsData { region_constraints: self.region_constraints.clone().fold_with(folder), opaque_types: self.opaque_types.iter().map(|opaque| opaque.fold_with(folder)).collect(), normalization_nested_goals: self.normalization_nested_goals.clone().fold_with(folder), @@ -94,19 +94,17 @@ impl<'tcx> TypeFoldable> for PredefinedOpaques<'tcx> { self, folder: &mut F, ) -> Result { - Ok(FallibleTypeFolder::interner(folder).mk_predefined_opaques_in_body( - PredefinedOpaquesData { - opaque_types: self - .opaque_types - .iter() - .map(|opaque| opaque.try_fold_with(folder)) - .collect::>()?, - }, - )) + Ok(FallibleTypeFolder::cx(folder).mk_predefined_opaques_in_body(PredefinedOpaquesData { + opaque_types: self + .opaque_types + .iter() + .map(|opaque| opaque.try_fold_with(folder)) + .collect::>()?, + })) } fn fold_with>>(self, folder: &mut F) -> Self { - TypeFolder::interner(folder).mk_predefined_opaques_in_body(PredefinedOpaquesData { + TypeFolder::cx(folder).mk_predefined_opaques_in_body(PredefinedOpaquesData { opaque_types: self.opaque_types.iter().map(|opaque| opaque.fold_with(folder)).collect(), }) } diff --git a/compiler/rustc_middle/src/ty/abstract_const.rs b/compiler/rustc_middle/src/ty/abstract_const.rs index fa44fbaa0599d..3aa01fbef2fbf 100644 --- a/compiler/rustc_middle/src/ty/abstract_const.rs +++ b/compiler/rustc_middle/src/ty/abstract_const.rs @@ -41,7 +41,7 @@ impl<'tcx> TyCtxt<'tcx> { } impl<'tcx> TypeFolder> for Expander<'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } fn fold_ty(&mut self, ty: Ty<'tcx>) -> Ty<'tcx> { diff --git a/compiler/rustc_middle/src/ty/diagnostics.rs b/compiler/rustc_middle/src/ty/diagnostics.rs index 8c3ee6955f5d2..4bf2233799130 100644 --- a/compiler/rustc_middle/src/ty/diagnostics.rs +++ b/compiler/rustc_middle/src/ty/diagnostics.rs @@ -579,7 +579,7 @@ pub struct MakeSuggestableFolder<'tcx> { impl<'tcx> FallibleTypeFolder> for MakeSuggestableFolder<'tcx> { type Error = (); - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } diff --git a/compiler/rustc_middle/src/ty/erase_regions.rs b/compiler/rustc_middle/src/ty/erase_regions.rs index cd6e7df31f7cd..9d5481f3df376 100644 --- a/compiler/rustc_middle/src/ty/erase_regions.rs +++ b/compiler/rustc_middle/src/ty/erase_regions.rs @@ -37,7 +37,7 @@ struct RegionEraserVisitor<'tcx> { } impl<'tcx> TypeFolder> for RegionEraserVisitor<'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } diff --git a/compiler/rustc_middle/src/ty/fold.rs b/compiler/rustc_middle/src/ty/fold.rs index 9b5b1430c27f7..81ea8738e7269 100644 --- a/compiler/rustc_middle/src/ty/fold.rs +++ b/compiler/rustc_middle/src/ty/fold.rs @@ -28,7 +28,7 @@ where G: FnMut(ty::Region<'tcx>) -> ty::Region<'tcx>, H: FnMut(ty::Const<'tcx>) -> ty::Const<'tcx>, { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } @@ -99,7 +99,7 @@ impl<'a, 'tcx> RegionFolder<'a, 'tcx> { } impl<'a, 'tcx> TypeFolder> for RegionFolder<'a, 'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } @@ -176,7 +176,7 @@ impl<'tcx, D> TypeFolder> for BoundVarReplacer<'tcx, D> where D: BoundVarReplacerDelegate<'tcx>, { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } diff --git a/compiler/rustc_middle/src/ty/generic_args.rs b/compiler/rustc_middle/src/ty/generic_args.rs index 83d45ca78d9d9..5ac3168196ad7 100644 --- a/compiler/rustc_middle/src/ty/generic_args.rs +++ b/compiler/rustc_middle/src/ty/generic_args.rs @@ -591,7 +591,7 @@ impl<'tcx> TypeFoldable> for GenericArgsRef<'tcx> { match self.len() { 1 => { let param0 = self[0].try_fold_with(folder)?; - if param0 == self[0] { Ok(self) } else { Ok(folder.interner().mk_args(&[param0])) } + if param0 == self[0] { Ok(self) } else { Ok(folder.cx().mk_args(&[param0])) } } 2 => { let param0 = self[0].try_fold_with(folder)?; @@ -599,7 +599,7 @@ impl<'tcx> TypeFoldable> for GenericArgsRef<'tcx> { if param0 == self[0] && param1 == self[1] { Ok(self) } else { - Ok(folder.interner().mk_args(&[param0, param1])) + Ok(folder.cx().mk_args(&[param0, param1])) } } 0 => Ok(self), @@ -635,7 +635,7 @@ impl<'tcx> TypeFoldable> for &'tcx ty::List> { if param0 == self[0] && param1 == self[1] { Ok(self) } else { - Ok(folder.interner().mk_type_list(&[param0, param1])) + Ok(folder.cx().mk_type_list(&[param0, param1])) } } _ => ty::util::fold_list(self, folder, |tcx, v| tcx.mk_type_list(v)), diff --git a/compiler/rustc_middle/src/ty/instance.rs b/compiler/rustc_middle/src/ty/instance.rs index efaf9c7231bb4..1ba8820e0e11d 100644 --- a/compiler/rustc_middle/src/ty/instance.rs +++ b/compiler/rustc_middle/src/ty/instance.rs @@ -873,7 +873,7 @@ fn polymorphize<'tcx>( } impl<'tcx> ty::TypeFolder> for PolymorphizationFolder<'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } diff --git a/compiler/rustc_middle/src/ty/normalize_erasing_regions.rs b/compiler/rustc_middle/src/ty/normalize_erasing_regions.rs index fb16cf5bd3632..96f00e1d3063a 100644 --- a/compiler/rustc_middle/src/ty/normalize_erasing_regions.rs +++ b/compiler/rustc_middle/src/ty/normalize_erasing_regions.rs @@ -173,7 +173,7 @@ impl<'tcx> NormalizeAfterErasingRegionsFolder<'tcx> { } impl<'tcx> TypeFolder> for NormalizeAfterErasingRegionsFolder<'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } @@ -211,7 +211,7 @@ impl<'tcx> TryNormalizeAfterErasingRegionsFolder<'tcx> { impl<'tcx> FallibleTypeFolder> for TryNormalizeAfterErasingRegionsFolder<'tcx> { type Error = NormalizationError<'tcx>; - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } diff --git a/compiler/rustc_middle/src/ty/opaque_types.rs b/compiler/rustc_middle/src/ty/opaque_types.rs index 08b2f9e892031..70a54e96d3678 100644 --- a/compiler/rustc_middle/src/ty/opaque_types.rs +++ b/compiler/rustc_middle/src/ty/opaque_types.rs @@ -95,7 +95,7 @@ impl<'tcx> ReverseMapper<'tcx> { } impl<'tcx> TypeFolder> for ReverseMapper<'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } @@ -144,7 +144,7 @@ impl<'tcx> TypeFolder> for ReverseMapper<'tcx> { ) .emit(); - ty::Region::new_error(self.interner(), e) + ty::Region::new_error(self.cx(), e) } } } diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs index 72cb3e134027f..19700353f5944 100644 --- a/compiler/rustc_middle/src/ty/print/pretty.rs +++ b/compiler/rustc_middle/src/ty/print/pretty.rs @@ -2529,7 +2529,7 @@ struct RegionFolder<'a, 'tcx> { } impl<'a, 'tcx> ty::TypeFolder> for RegionFolder<'a, 'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs index 71e2e3e9f9942..a9dca47ab4373 100644 --- a/compiler/rustc_middle/src/ty/structural_impls.rs +++ b/compiler/rustc_middle/src/ty/structural_impls.rs @@ -335,7 +335,7 @@ impl<'tcx> TypeFoldable> for Pattern<'tcx> { folder: &mut F, ) -> Result { let pat = (*self).clone().try_fold_with(folder)?; - Ok(if pat == *self { self } else { folder.interner().mk_pat(pat) }) + Ok(if pat == *self { self } else { folder.cx().mk_pat(pat) }) } } @@ -407,7 +407,7 @@ impl<'tcx> TypeSuperFoldable> for Ty<'tcx> { | ty::Foreign(..) => return Ok(self), }; - Ok(if *self.kind() == kind { self } else { folder.interner().mk_ty_from_kind(kind) }) + Ok(if *self.kind() == kind { self } else { folder.cx().mk_ty_from_kind(kind) }) } } @@ -512,7 +512,7 @@ impl<'tcx> TypeSuperFoldable> for ty::Predicate<'tcx> { folder: &mut F, ) -> Result { let new = self.kind().try_fold_with(folder)?; - Ok(folder.interner().reuse_or_mk_predicate(self, new)) + Ok(folder.cx().reuse_or_mk_predicate(self, new)) } } @@ -577,7 +577,7 @@ impl<'tcx> TypeSuperFoldable> for ty::Const<'tcx> { ConstKind::Error(e) => ConstKind::Error(e.try_fold_with(folder)?), ConstKind::Expr(e) => ConstKind::Expr(e.try_fold_with(folder)?), }; - if kind != self.kind() { Ok(folder.interner().mk_ct_from_kind(kind)) } else { Ok(self) } + if kind != self.kind() { Ok(folder.cx().mk_ct_from_kind(kind)) } else { Ok(self) } } } diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs index b079ed521d34c..1b5efcee90355 100644 --- a/compiler/rustc_middle/src/ty/util.rs +++ b/compiler/rustc_middle/src/ty/util.rs @@ -1083,7 +1083,7 @@ impl<'tcx> OpaqueTypeExpander<'tcx> { } impl<'tcx> TypeFolder> for OpaqueTypeExpander<'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } @@ -1130,7 +1130,7 @@ struct WeakAliasTypeExpander<'tcx> { } impl<'tcx> TypeFolder> for WeakAliasTypeExpander<'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } @@ -1795,7 +1795,7 @@ where for t in iter { new_list.push(t.try_fold_with(folder)?) } - Ok(intern(folder.interner(), &new_list)) + Ok(intern(folder.cx(), &new_list)) } Some((_, Err(err))) => { return Err(err); diff --git a/compiler/rustc_next_trait_solver/src/canonicalizer.rs b/compiler/rustc_next_trait_solver/src/canonicalizer.rs index a81fd03d034f7..695d02705abd2 100644 --- a/compiler/rustc_next_trait_solver/src/canonicalizer.rs +++ b/compiler/rustc_next_trait_solver/src/canonicalizer.rs @@ -7,7 +7,7 @@ use rustc_type_ir::{ self as ty, Canonical, CanonicalTyVarKind, CanonicalVarInfo, CanonicalVarKind, Interner, }; -use crate::infcx::SolverDelegate; +use crate::delegate::SolverDelegate; /// Whether we're canonicalizing a query input or the query response. /// @@ -38,8 +38,8 @@ pub enum CanonicalizeMode { }, } -pub struct Canonicalizer<'a, Infcx: SolverDelegate, I: Interner> { - infcx: &'a Infcx, +pub struct Canonicalizer<'a, D: SolverDelegate, I: Interner> { + delegate: &'a D, canonicalize_mode: CanonicalizeMode, variables: &'a mut Vec, @@ -47,15 +47,15 @@ pub struct Canonicalizer<'a, Infcx: SolverDelegate, I: Interner> { binder_index: ty::DebruijnIndex, } -impl<'a, Infcx: SolverDelegate, I: Interner> Canonicalizer<'a, Infcx, I> { +impl<'a, D: SolverDelegate, I: Interner> Canonicalizer<'a, D, I> { pub fn canonicalize>( - infcx: &'a Infcx, + delegate: &'a D, canonicalize_mode: CanonicalizeMode, variables: &'a mut Vec, value: T, ) -> ty::Canonical { let mut canonicalizer = Canonicalizer { - infcx, + delegate, canonicalize_mode, variables, @@ -70,7 +70,7 @@ impl<'a, Infcx: SolverDelegate, I: Interner> Canonicalizer<'a, Inf let (max_universe, variables) = canonicalizer.finalize(); - let defining_opaque_types = infcx.defining_opaque_types(); + let defining_opaque_types = delegate.defining_opaque_types(); Canonical { defining_opaque_types, max_universe, variables, value } } @@ -102,7 +102,7 @@ impl<'a, Infcx: SolverDelegate, I: Interner> Canonicalizer<'a, Inf .max() .unwrap_or(ty::UniverseIndex::ROOT); - let var_infos = self.infcx.interner().mk_canonical_var_infos(&var_infos); + let var_infos = self.delegate.cx().mk_canonical_var_infos(&var_infos); return (max_universe, var_infos); } } @@ -206,16 +206,14 @@ impl<'a, Infcx: SolverDelegate, I: Interner> Canonicalizer<'a, Inf } } - let var_infos = self.infcx.interner().mk_canonical_var_infos(&var_infos); + let var_infos = self.delegate.cx().mk_canonical_var_infos(&var_infos); (curr_compressed_uv, var_infos) } } -impl, I: Interner> TypeFolder - for Canonicalizer<'_, Infcx, I> -{ - fn interner(&self) -> I { - self.infcx.interner() +impl, I: Interner> TypeFolder for Canonicalizer<'_, D, I> { + fn cx(&self) -> I { + self.delegate.cx() } fn fold_binder(&mut self, t: ty::Binder) -> ty::Binder @@ -267,14 +265,14 @@ impl, I: Interner> TypeFolder ty::ReVar(vid) => { assert_eq!( - self.infcx.opportunistic_resolve_lt_var(vid), + self.delegate.opportunistic_resolve_lt_var(vid), r, "region vid should have been resolved fully before canonicalization" ); match self.canonicalize_mode { CanonicalizeMode::Input => CanonicalVarKind::Region(ty::UniverseIndex::ROOT), CanonicalizeMode::Response { .. } => { - CanonicalVarKind::Region(self.infcx.universe_of_lt(vid).unwrap()) + CanonicalVarKind::Region(self.delegate.universe_of_lt(vid).unwrap()) } } } @@ -294,7 +292,7 @@ impl, I: Interner> TypeFolder var }); - Region::new_anon_bound(self.interner(), self.binder_index, var) + Region::new_anon_bound(self.cx(), self.binder_index, var) } fn fold_ty(&mut self, t: I::Ty) -> I::Ty { @@ -302,20 +300,20 @@ impl, I: Interner> TypeFolder ty::Infer(i) => match i { ty::TyVar(vid) => { assert_eq!( - self.infcx.opportunistic_resolve_ty_var(vid), + self.delegate.opportunistic_resolve_ty_var(vid), t, "ty vid should have been resolved fully before canonicalization" ); CanonicalVarKind::Ty(CanonicalTyVarKind::General( - self.infcx + self.delegate .universe_of_ty(vid) .unwrap_or_else(|| panic!("ty var should have been resolved: {t:?}")), )) } ty::IntVar(vid) => { assert_eq!( - self.infcx.opportunistic_resolve_int_var(vid), + self.delegate.opportunistic_resolve_int_var(vid), t, "ty vid should have been resolved fully before canonicalization" ); @@ -323,7 +321,7 @@ impl, I: Interner> TypeFolder } ty::FloatVar(vid) => { assert_eq!( - self.infcx.opportunistic_resolve_float_var(vid), + self.delegate.opportunistic_resolve_float_var(vid), t, "ty vid should have been resolved fully before canonicalization" ); @@ -383,7 +381,7 @@ impl, I: Interner> TypeFolder }), ); - Ty::new_anon_bound(self.interner(), self.binder_index, var) + Ty::new_anon_bound(self.cx(), self.binder_index, var) } fn fold_const(&mut self, c: I::Const) -> I::Const { @@ -391,11 +389,11 @@ impl, I: Interner> TypeFolder ty::ConstKind::Infer(i) => match i { ty::InferConst::Var(vid) => { assert_eq!( - self.infcx.opportunistic_resolve_ct_var(vid), + self.delegate.opportunistic_resolve_ct_var(vid), c, "const vid should have been resolved fully before canonicalization" ); - CanonicalVarKind::Const(self.infcx.universe_of_ct(vid).unwrap()) + CanonicalVarKind::Const(self.delegate.universe_of_ct(vid).unwrap()) } ty::InferConst::EffectVar(_) => CanonicalVarKind::Effect, ty::InferConst::Fresh(_) => todo!(), @@ -431,6 +429,6 @@ impl, I: Interner> TypeFolder }), ); - Const::new_anon_bound(self.interner(), self.binder_index, var) + Const::new_anon_bound(self.cx(), self.binder_index, var) } } diff --git a/compiler/rustc_next_trait_solver/src/infcx.rs b/compiler/rustc_next_trait_solver/src/delegate.rs similarity index 98% rename from compiler/rustc_next_trait_solver/src/infcx.rs rename to compiler/rustc_next_trait_solver/src/delegate.rs index c249eb94cf654..6626acfe9639e 100644 --- a/compiler/rustc_next_trait_solver/src/infcx.rs +++ b/compiler/rustc_next_trait_solver/src/delegate.rs @@ -7,14 +7,14 @@ use rustc_type_ir::{self as ty, Interner}; pub trait SolverDelegate: Sized { type Interner: Interner; - fn interner(&self) -> Self::Interner; + fn cx(&self) -> Self::Interner; type Span: Copy; fn solver_mode(&self) -> SolverMode; fn build_with_canonical( - interner: Self::Interner, + cx: Self::Interner, solver_mode: SolverMode, canonical: &ty::Canonical, ) -> (Self, V, ty::CanonicalVarValues) @@ -102,7 +102,7 @@ pub trait SolverDelegate: Sized { // FIXME: This is only here because elaboration lives in `rustc_infer`! fn elaborate_supertraits( - interner: Self::Interner, + cx: Self::Interner, trait_ref: ty::Binder>, ) -> impl Iterator>>; diff --git a/compiler/rustc_next_trait_solver/src/lib.rs b/compiler/rustc_next_trait_solver/src/lib.rs index ea3e18872fa41..a6a9c01faaa0f 100644 --- a/compiler/rustc_next_trait_solver/src/lib.rs +++ b/compiler/rustc_next_trait_solver/src/lib.rs @@ -5,6 +5,6 @@ //! So if you got to this crate from the old solver, it's totally normal. pub mod canonicalizer; -pub mod infcx; +pub mod delegate; pub mod resolve; pub mod solve; diff --git a/compiler/rustc_next_trait_solver/src/resolve.rs b/compiler/rustc_next_trait_solver/src/resolve.rs index 3d8d957eaae4f..6ed58d0e4fb66 100644 --- a/compiler/rustc_next_trait_solver/src/resolve.rs +++ b/compiler/rustc_next_trait_solver/src/resolve.rs @@ -1,4 +1,4 @@ -use crate::infcx::SolverDelegate; +use crate::delegate::SolverDelegate; use rustc_type_ir::fold::{TypeFoldable, TypeFolder, TypeSuperFoldable}; use rustc_type_ir::inherent::*; use rustc_type_ir::visit::TypeVisitableExt; @@ -8,37 +8,37 @@ use rustc_type_ir::{self as ty, Interner}; // EAGER RESOLUTION /// Resolves ty, region, and const vars to their inferred values or their root vars. -pub struct EagerResolver<'a, Infcx, I = ::Interner> +pub struct EagerResolver<'a, D, I = ::Interner> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { - infcx: &'a Infcx, + delegate: &'a D, } -impl<'a, Infcx: SolverDelegate> EagerResolver<'a, Infcx> { - pub fn new(infcx: &'a Infcx) -> Self { - EagerResolver { infcx } +impl<'a, D: SolverDelegate> EagerResolver<'a, D> { + pub fn new(delegate: &'a D) -> Self { + EagerResolver { delegate } } } -impl, I: Interner> TypeFolder for EagerResolver<'_, Infcx> { - fn interner(&self) -> I { - self.infcx.interner() +impl, I: Interner> TypeFolder for EagerResolver<'_, D> { + fn cx(&self) -> I { + self.delegate.cx() } fn fold_ty(&mut self, t: I::Ty) -> I::Ty { match t.kind() { ty::Infer(ty::TyVar(vid)) => { - let resolved = self.infcx.opportunistic_resolve_ty_var(vid); + let resolved = self.delegate.opportunistic_resolve_ty_var(vid); if t != resolved && resolved.has_infer() { resolved.fold_with(self) } else { resolved } } - ty::Infer(ty::IntVar(vid)) => self.infcx.opportunistic_resolve_int_var(vid), - ty::Infer(ty::FloatVar(vid)) => self.infcx.opportunistic_resolve_float_var(vid), + ty::Infer(ty::IntVar(vid)) => self.delegate.opportunistic_resolve_int_var(vid), + ty::Infer(ty::FloatVar(vid)) => self.delegate.opportunistic_resolve_float_var(vid), _ => { if t.has_infer() { t.super_fold_with(self) @@ -51,7 +51,7 @@ impl, I: Interner> TypeFolder for EagerRe fn fold_region(&mut self, r: I::Region) -> I::Region { match r.kind() { - ty::ReVar(vid) => self.infcx.opportunistic_resolve_lt_var(vid), + ty::ReVar(vid) => self.delegate.opportunistic_resolve_lt_var(vid), _ => r, } } @@ -59,7 +59,7 @@ impl, I: Interner> TypeFolder for EagerRe fn fold_const(&mut self, c: I::Const) -> I::Const { match c.kind() { ty::ConstKind::Infer(ty::InferConst::Var(vid)) => { - let resolved = self.infcx.opportunistic_resolve_ct_var(vid); + let resolved = self.delegate.opportunistic_resolve_ct_var(vid); if c != resolved && resolved.has_infer() { resolved.fold_with(self) } else { @@ -67,7 +67,7 @@ impl, I: Interner> TypeFolder for EagerRe } } ty::ConstKind::Infer(ty::InferConst::EffectVar(vid)) => { - self.infcx.opportunistic_resolve_effect_var(vid) + self.delegate.opportunistic_resolve_effect_var(vid) } _ => { if c.has_infer() { diff --git a/compiler/rustc_next_trait_solver/src/solve/alias_relate.rs b/compiler/rustc_next_trait_solver/src/solve/alias_relate.rs index fbc8ac1d5d5c5..5a95f4edf1915 100644 --- a/compiler/rustc_next_trait_solver/src/solve/alias_relate.rs +++ b/compiler/rustc_next_trait_solver/src/solve/alias_relate.rs @@ -19,12 +19,12 @@ use rustc_type_ir::inherent::*; use rustc_type_ir::{self as ty, Interner}; use tracing::{instrument, trace}; -use crate::infcx::SolverDelegate; +use crate::delegate::SolverDelegate; use crate::solve::{Certainty, EvalCtxt, Goal, QueryResult}; -impl EvalCtxt<'_, Infcx> +impl EvalCtxt<'_, D> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { #[instrument(level = "trace", skip(self), ret)] @@ -32,7 +32,7 @@ where &mut self, goal: Goal, ) -> QueryResult { - let tcx = self.interner(); + let tcx = self.cx(); let Goal { param_env, predicate: (lhs, rhs, direction) } = goal; debug_assert!(lhs.to_alias_term().is_some() || rhs.to_alias_term().is_some()); diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs index 9a1537d260608..cae9c5c85678e 100644 --- a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs +++ b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs @@ -9,7 +9,7 @@ use rustc_type_ir::visit::TypeVisitableExt as _; use rustc_type_ir::{self as ty, Interner, Upcast as _}; use tracing::{debug, instrument}; -use crate::infcx::SolverDelegate; +use crate::delegate::SolverDelegate; use crate::solve::inspect::ProbeKind; use crate::solve::{ BuiltinImplSource, CandidateSource, CanonicalResponse, Certainty, EvalCtxt, Goal, GoalSource, @@ -28,10 +28,10 @@ pub(super) struct Candidate { } /// Methods used to assemble candidates for either trait or projection goals. -pub(super) trait GoalKind::Interner>: +pub(super) trait GoalKind::Interner>: TypeFoldable + Copy + Eq + std::fmt::Display where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { fn self_ty(self) -> I::Ty; @@ -47,18 +47,18 @@ where /// work, then produce a response (typically by executing /// [`EvalCtxt::evaluate_added_goals_and_make_canonical_response`]). fn probe_and_match_goal_against_assumption( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, source: CandidateSource, goal: Goal, assumption: I::Clause, - then: impl FnOnce(&mut EvalCtxt<'_, Infcx>) -> QueryResult, + then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult, ) -> Result, NoSolution>; /// Consider a clause, which consists of a "assumption" and some "requirements", /// to satisfy a goal. If the requirements hold, then attempt to satisfy our /// goal by equating it with the assumption. fn probe_and_consider_implied_clause( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, parent_source: CandidateSource, goal: Goal, assumption: I::Clause, @@ -76,13 +76,13 @@ where /// additionally checking all of the supertraits and object bounds to hold, /// since they're not implied by the well-formedness of the object type. fn probe_and_consider_object_bound_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, source: CandidateSource, goal: Goal, assumption: I::Clause, ) -> Result, NoSolution> { Self::probe_and_match_goal_against_assumption(ecx, source, goal, assumption, |ecx| { - let tcx = ecx.interner(); + let tcx = ecx.cx(); let ty::Dynamic(bounds, _, _) = goal.predicate.self_ty().kind() else { panic!("expected object type in `probe_and_consider_object_bound_candidate`"); }; @@ -100,7 +100,7 @@ where } fn consider_impl_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, impl_def_id: I::DefId, ) -> Result, NoSolution>; @@ -112,7 +112,7 @@ where /// Trait goals always hold while projection goals never do. This is a bit arbitrary /// but prevents incorrect normalization while hiding any trait errors. fn consider_error_guaranteed_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, guar: I::ErrorGuaranteed, ) -> Result, NoSolution>; @@ -121,13 +121,13 @@ where /// These components are given by built-in rules from /// [`structural_traits::instantiate_constituent_tys_for_auto_trait`]. fn consider_auto_trait_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution>; /// A trait alias holds if the RHS traits and `where` clauses hold. fn consider_trait_alias_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution>; @@ -136,7 +136,7 @@ where /// These components are given by built-in rules from /// [`structural_traits::instantiate_constituent_tys_for_sized_trait`]. fn consider_builtin_sized_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution>; @@ -145,27 +145,27 @@ where /// These components are given by built-in rules from /// [`structural_traits::instantiate_constituent_tys_for_copy_clone_trait`]. fn consider_builtin_copy_clone_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution>; /// A type is `PointerLike` if we can compute its layout, and that layout /// matches the layout of `usize`. fn consider_builtin_pointer_like_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution>; /// A type is a `FnPtr` if it is of `FnPtr` type. fn consider_builtin_fn_ptr_trait_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution>; /// A callable type (a closure, fn def, or fn ptr) is known to implement the `Fn` /// family of traits where `A` is given by the signature of the type. fn consider_builtin_fn_trait_candidates( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, kind: ty::ClosureKind, ) -> Result, NoSolution>; @@ -173,7 +173,7 @@ where /// An async closure is known to implement the `AsyncFn` family of traits /// where `A` is given by the signature of the type. fn consider_builtin_async_fn_trait_candidates( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, kind: ty::ClosureKind, ) -> Result, NoSolution>; @@ -182,13 +182,13 @@ where /// is used internally to delay computation for async closures until after /// upvar analysis is performed in HIR typeck. fn consider_builtin_async_fn_kind_helper_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution>; /// `Tuple` is implemented if the `Self` type is a tuple. fn consider_builtin_tuple_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution>; @@ -198,7 +198,7 @@ where /// the built-in types. For structs, the metadata type is given by the struct /// tail. fn consider_builtin_pointee_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution>; @@ -206,7 +206,7 @@ where /// `Future`, where `O` is given by the coroutine's return type /// that was computed during type-checking. fn consider_builtin_future_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution>; @@ -214,19 +214,19 @@ where /// `Iterator`, where `O` is given by the generator's yield type /// that was computed during type-checking. fn consider_builtin_iterator_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution>; /// A coroutine (that comes from a `gen` desugaring) is known to implement /// `FusedIterator` fn consider_builtin_fused_iterator_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution>; fn consider_builtin_async_iterator_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution>; @@ -234,27 +234,27 @@ where /// implement `Coroutine`, given the resume, yield, /// and return types of the coroutine computed during type-checking. fn consider_builtin_coroutine_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution>; fn consider_builtin_discriminant_kind_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution>; fn consider_builtin_async_destruct_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution>; fn consider_builtin_destruct_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution>; fn consider_builtin_transmute_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution>; @@ -266,17 +266,17 @@ where /// otherwise recompute this for codegen. This is a bit of a mess but the /// easiest way to maintain the existing behavior for now. fn consider_structural_builtin_unsize_candidates( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Vec>; } -impl EvalCtxt<'_, Infcx> +impl EvalCtxt<'_, D> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { - pub(super) fn assemble_and_evaluate_candidates>( + pub(super) fn assemble_and_evaluate_candidates>( &mut self, goal: Goal, ) -> Vec> { @@ -291,10 +291,8 @@ where return self.forced_ambiguity(MaybeCause::Ambiguity).into_iter().collect(); } - let goal: Goal = goal.with( - self.interner(), - goal.predicate.with_self_ty(self.interner(), normalized_self_ty), - ); + let goal: Goal = + goal.with(self.cx(), goal.predicate.with_self_ty(self.cx(), normalized_self_ty)); // Vars that show up in the rest of the goal substs may have been constrained by // normalizing the self type as well, since type variables are not uniquified. let goal = self.resolve_vars_if_possible(goal); @@ -337,12 +335,12 @@ where } #[instrument(level = "trace", skip_all)] - fn assemble_impl_candidates>( + fn assemble_impl_candidates>( &mut self, goal: Goal, candidates: &mut Vec>, ) { - let tcx = self.interner(); + let tcx = self.cx(); tcx.for_each_relevant_impl( goal.predicate.trait_def_id(tcx), goal.predicate.self_ty(), @@ -363,12 +361,12 @@ where } #[instrument(level = "trace", skip_all)] - fn assemble_builtin_impl_candidates>( + fn assemble_builtin_impl_candidates>( &mut self, goal: Goal, candidates: &mut Vec>, ) { - let tcx = self.interner(); + let tcx = self.cx(); let trait_def_id = goal.predicate.trait_def_id(tcx); // N.B. When assembling built-in candidates for lang items that are also @@ -394,9 +392,9 @@ where G::consider_builtin_pointer_like_candidate(self, goal) } else if tcx.is_lang_item(trait_def_id, TraitSolverLangItem::FnPtrTrait) { G::consider_builtin_fn_ptr_trait_candidate(self, goal) - } else if let Some(kind) = self.interner().fn_trait_kind_from_def_id(trait_def_id) { + } else if let Some(kind) = self.cx().fn_trait_kind_from_def_id(trait_def_id) { G::consider_builtin_fn_trait_candidates(self, goal, kind) - } else if let Some(kind) = self.interner().async_fn_trait_kind_from_def_id(trait_def_id) { + } else if let Some(kind) = self.cx().async_fn_trait_kind_from_def_id(trait_def_id) { G::consider_builtin_async_fn_trait_candidates(self, goal, kind) } else if tcx.is_lang_item(trait_def_id, TraitSolverLangItem::AsyncFnKindHelper) { G::consider_builtin_async_fn_kind_helper_candidate(self, goal) @@ -436,7 +434,7 @@ where } #[instrument(level = "trace", skip_all)] - fn assemble_param_env_candidates>( + fn assemble_param_env_candidates>( &mut self, goal: Goal, candidates: &mut Vec>, @@ -453,7 +451,7 @@ where } #[instrument(level = "trace", skip_all)] - fn assemble_alias_bound_candidates>( + fn assemble_alias_bound_candidates>( &mut self, goal: Goal, candidates: &mut Vec>, @@ -472,7 +470,7 @@ where /// If so, continue searching by recursively calling after normalization. // FIXME: This may recurse infinitely, but I can't seem to trigger it without // hitting another overflow error something. Add a depth parameter needed later. - fn assemble_alias_bound_candidates_recur>( + fn assemble_alias_bound_candidates_recur>( &mut self, self_ty: I::Ty, goal: Goal, @@ -523,15 +521,13 @@ where ty::Alias(kind @ (ty::Projection | ty::Opaque), alias_ty) => (kind, alias_ty), ty::Alias(ty::Inherent | ty::Weak, _) => { - self.interner().delay_bug(format!("could not normalize {self_ty:?}, it is not WF")); + self.cx().delay_bug(format!("could not normalize {self_ty:?}, it is not WF")); return; } }; - for assumption in self - .interner() - .item_bounds(alias_ty.def_id) - .iter_instantiated(self.interner(), &alias_ty.args) + for assumption in + self.cx().item_bounds(alias_ty.def_id).iter_instantiated(self.cx(), &alias_ty.args) { candidates.extend(G::probe_and_consider_implied_clause( self, @@ -556,12 +552,12 @@ where } #[instrument(level = "trace", skip_all)] - fn assemble_object_bound_candidates>( + fn assemble_object_bound_candidates>( &mut self, goal: Goal, candidates: &mut Vec>, ) { - let tcx = self.interner(); + let tcx = self.cx(); if !tcx.trait_may_be_implemented_via_object(goal.predicate.trait_def_id(tcx)) { return; } @@ -629,8 +625,7 @@ where // a projection goal. if let Some(principal) = bounds.principal() { let principal_trait_ref = principal.with_self_ty(tcx, self_ty); - for (idx, assumption) in - Infcx::elaborate_supertraits(tcx, principal_trait_ref).enumerate() + for (idx, assumption) in D::elaborate_supertraits(tcx, principal_trait_ref).enumerate() { candidates.extend(G::probe_and_consider_object_bound_candidate( self, @@ -649,12 +644,12 @@ where /// To do so we add an ambiguous candidate in case such an unknown impl could /// apply to the current goal. #[instrument(level = "trace", skip_all)] - fn assemble_coherence_unknowable_candidates>( + fn assemble_coherence_unknowable_candidates>( &mut self, goal: Goal, candidates: &mut Vec>, ) { - let tcx = self.interner(); + let tcx = self.cx(); candidates.extend(self.probe_trait_candidate(CandidateSource::CoherenceUnknowable).enter( |ecx| { @@ -678,12 +673,12 @@ where // to improve this however. However, this should make it fairly straightforward to refine // the filtering going forward, so it seems alright-ish for now. #[instrument(level = "debug", skip(self, goal))] - fn discard_impls_shadowed_by_env>( + fn discard_impls_shadowed_by_env>( &mut self, goal: Goal, candidates: &mut Vec>, ) { - let tcx = self.interner(); + let tcx = self.cx(); let trait_goal: Goal> = goal.with(tcx, goal.predicate.trait_ref(tcx)); diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs index dbe3dfd4a1b57..b10be5a9ba700 100644 --- a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs +++ b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs @@ -10,20 +10,20 @@ use rustc_type_ir::{self as ty, Interner, Upcast as _}; use rustc_type_ir_macros::{TypeFoldable_Generic, TypeVisitable_Generic}; use tracing::instrument; -use crate::infcx::SolverDelegate; +use crate::delegate::SolverDelegate; use crate::solve::{EvalCtxt, Goal, NoSolution}; // Calculates the constituent types of a type for `auto trait` purposes. #[instrument(level = "trace", skip(ecx), ret)] -pub(in crate::solve) fn instantiate_constituent_tys_for_auto_trait( - ecx: &EvalCtxt<'_, Infcx>, +pub(in crate::solve) fn instantiate_constituent_tys_for_auto_trait( + ecx: &EvalCtxt<'_, D>, ty: I::Ty, ) -> Result>, NoSolution> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { - let tcx = ecx.interner(); + let tcx = ecx.cx(); match ty.kind() { ty::Uint(_) | ty::Int(_) @@ -76,7 +76,7 @@ where } ty::CoroutineWitness(def_id, args) => Ok(ecx - .interner() + .cx() .bound_coroutine_hidden_types(def_id) .into_iter() .map(|bty| bty.instantiate(tcx, &args)) @@ -101,12 +101,12 @@ where } #[instrument(level = "trace", skip(ecx), ret)] -pub(in crate::solve) fn instantiate_constituent_tys_for_sized_trait( - ecx: &EvalCtxt<'_, Infcx>, +pub(in crate::solve) fn instantiate_constituent_tys_for_sized_trait( + ecx: &EvalCtxt<'_, D>, ty: I::Ty, ) -> Result>, NoSolution> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { match ty.kind() { @@ -159,8 +159,8 @@ where // "best effort" optimization and `sized_constraint` may return `Some`, even // if the ADT is sized for all possible args. ty::Adt(def, args) => { - if let Some(sized_crit) = def.sized_constraint(ecx.interner()) { - Ok(vec![ty::Binder::dummy(sized_crit.instantiate(ecx.interner(), &args))]) + if let Some(sized_crit) = def.sized_constraint(ecx.cx()) { + Ok(vec![ty::Binder::dummy(sized_crit.instantiate(ecx.cx(), &args))]) } else { Ok(vec![]) } @@ -169,12 +169,12 @@ where } #[instrument(level = "trace", skip(ecx), ret)] -pub(in crate::solve) fn instantiate_constituent_tys_for_copy_clone_trait( - ecx: &EvalCtxt<'_, Infcx>, +pub(in crate::solve) fn instantiate_constituent_tys_for_copy_clone_trait( + ecx: &EvalCtxt<'_, D>, ty: I::Ty, ) -> Result>, NoSolution> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { match ty.kind() { @@ -222,10 +222,10 @@ where // only when `coroutine_clone` is enabled and the coroutine is movable // impl Copy/Clone for Coroutine where T: Copy/Clone forall T in (upvars, witnesses) - ty::Coroutine(def_id, args) => match ecx.interner().coroutine_movability(def_id) { + ty::Coroutine(def_id, args) => match ecx.cx().coroutine_movability(def_id) { Movability::Static => Err(NoSolution), Movability::Movable => { - if ecx.interner().features().coroutine_clone() { + if ecx.cx().features().coroutine_clone() { let coroutine = args.as_coroutine(); Ok(vec![ ty::Binder::dummy(coroutine.tupled_upvars_ty()), @@ -239,10 +239,10 @@ where // impl Copy/Clone for CoroutineWitness where T: Copy/Clone forall T in coroutine_hidden_types ty::CoroutineWitness(def_id, args) => Ok(ecx - .interner() + .cx() .bound_coroutine_hidden_types(def_id) .into_iter() - .map(|bty| bty.instantiate(ecx.interner(), &args)) + .map(|bty| bty.instantiate(ecx.cx(), &args)) .collect()), } } @@ -656,17 +656,17 @@ fn coroutine_closure_to_ambiguous_coroutine( // This is unsound in general and once that is fixed, we don't need to // normalize eagerly here. See https://github.com/lcnr/solver-woes/issues/9 // for more details. -pub(in crate::solve) fn predicates_for_object_candidate( - ecx: &EvalCtxt<'_, Infcx>, +pub(in crate::solve) fn predicates_for_object_candidate( + ecx: &EvalCtxt<'_, D>, param_env: I::ParamEnv, trait_ref: ty::TraitRef, object_bounds: I::BoundExistentialPredicates, ) -> Vec> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { - let tcx = ecx.interner(); + let tcx = ecx.cx(); let mut requirements = vec![]; requirements .extend(tcx.super_predicates_of(trait_ref.def_id).iter_instantiated(tcx, &trait_ref.args)); @@ -712,18 +712,18 @@ where .collect() } -struct ReplaceProjectionWith<'a, Infcx: SolverDelegate, I: Interner> { - ecx: &'a EvalCtxt<'a, Infcx>, +struct ReplaceProjectionWith<'a, D: SolverDelegate, I: Interner> { + ecx: &'a EvalCtxt<'a, D>, param_env: I::ParamEnv, mapping: HashMap>>, nested: Vec>, } -impl, I: Interner> TypeFolder - for ReplaceProjectionWith<'_, Infcx, I> +impl, I: Interner> TypeFolder + for ReplaceProjectionWith<'_, D, I> { - fn interner(&self) -> I { - self.ecx.interner() + fn cx(&self) -> I { + self.ecx.cx() } fn fold_ty(&mut self, ty: I::Ty) -> I::Ty { @@ -739,7 +739,7 @@ impl, I: Interner> TypeFolder .eq_and_get_goals( self.param_env, alias_ty, - proj.projection_term.expect_ty(self.ecx.interner()), + proj.projection_term.expect_ty(self.ecx.cx()), ) .expect( "expected to be able to unify goal projection with dyn's projection", diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs index c6611285a3bed..f1d4864a84b74 100644 --- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs +++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs @@ -18,7 +18,7 @@ use rustc_type_ir::{self as ty, Canonical, CanonicalVarValues, Interner}; use tracing::{instrument, trace}; use crate::canonicalizer::{CanonicalizeMode, Canonicalizer}; -use crate::infcx::SolverDelegate; +use crate::delegate::SolverDelegate; use crate::resolve::EagerResolver; use crate::solve::eval_ctxt::NestedGoals; use crate::solve::inspect; @@ -44,9 +44,9 @@ impl ResponseT for inspect::State { } } -impl EvalCtxt<'_, Infcx> +impl EvalCtxt<'_, D> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { /// Canonicalizes the goal remembering the original values @@ -55,19 +55,19 @@ where &self, goal: Goal, ) -> (Vec, CanonicalInput) { - let opaque_types = self.infcx.clone_opaque_types_for_query_response(); + let opaque_types = self.delegate.clone_opaque_types_for_query_response(); let (goal, opaque_types) = - (goal, opaque_types).fold_with(&mut EagerResolver::new(self.infcx)); + (goal, opaque_types).fold_with(&mut EagerResolver::new(self.delegate)); let mut orig_values = Default::default(); let canonical_goal = Canonicalizer::canonicalize( - self.infcx, + self.delegate, CanonicalizeMode::Input, &mut orig_values, QueryInput { goal, predefined_opaques_in_body: self - .interner() + .cx() .mk_predefined_opaques_in_body(PredefinedOpaquesData { opaque_types }), }, ); @@ -97,7 +97,7 @@ where // We only check for leaks from universes which were entered inside // of the query. - self.infcx.leak_check(self.max_input_universe).map_err(|NoSolution| { + self.delegate.leak_check(self.max_input_universe).map_err(|NoSolution| { trace!("failed the leak check"); NoSolution })?; @@ -125,21 +125,21 @@ where let external_constraints = self.compute_external_query_constraints(certainty, normalization_nested_goals); - let (var_values, mut external_constraints) = - (self.var_values, external_constraints).fold_with(&mut EagerResolver::new(self.infcx)); + let (var_values, mut external_constraints) = (self.var_values, external_constraints) + .fold_with(&mut EagerResolver::new(self.delegate)); // Remove any trivial region constraints once we've resolved regions external_constraints .region_constraints .retain(|outlives| outlives.0.as_region().map_or(true, |re| re != outlives.1)); let canonical = Canonicalizer::canonicalize( - self.infcx, + self.delegate, CanonicalizeMode::Response { max_input_universe: self.max_input_universe }, &mut Default::default(), Response { var_values, certainty, - external_constraints: self.interner().mk_external_constraints(external_constraints), + external_constraints: self.cx().mk_external_constraints(external_constraints), }, ); @@ -155,7 +155,7 @@ where maybe_cause: MaybeCause, ) -> CanonicalResponse { response_no_constraints_raw( - self.interner(), + self.cx(), self.max_input_universe, self.variables, Certainty::Maybe(maybe_cause), @@ -184,7 +184,7 @@ where // `tests/ui/higher-ranked/leak-check/leak-check-in-selection-5-ambig.rs` and // `tests/ui/higher-ranked/leak-check/leak-check-in-selection-6-ambig-unify.rs`. let region_constraints = if certainty == Certainty::Yes { - self.infcx.make_deduplicated_outlives_constraints() + self.delegate.make_deduplicated_outlives_constraints() } else { Default::default() }; @@ -192,7 +192,7 @@ where ExternalConstraintsData { region_constraints, opaque_types: self - .infcx + .delegate .clone_opaque_types_for_query_response() .into_iter() // Only return *newly defined* opaque types. @@ -219,15 +219,15 @@ where response: CanonicalResponse, ) -> (NestedNormalizationGoals, Certainty) { let instantiation = Self::compute_query_response_instantiation_values( - self.infcx, + self.delegate, &original_values, &response, ); let Response { var_values, external_constraints, certainty } = - self.infcx.instantiate_canonical(response, instantiation); + self.delegate.instantiate_canonical(response, instantiation); - Self::unify_query_var_values(self.infcx, param_env, &original_values, var_values); + Self::unify_query_var_values(self.delegate, param_env, &original_values, var_values); let ExternalConstraintsData { region_constraints, @@ -243,17 +243,17 @@ where /// the canonical response. This depends on the `original_values` for the /// bound variables. fn compute_query_response_instantiation_values>( - infcx: &Infcx, + delegate: &D, original_values: &[I::GenericArg], response: &Canonical, ) -> CanonicalVarValues { // FIXME: Longterm canonical queries should deal with all placeholders // created inside of the query directly instead of returning them to the // caller. - let prev_universe = infcx.universe(); + let prev_universe = delegate.universe(); let universes_created_in_query = response.max_universe.index(); for _ in 0..universes_created_in_query { - infcx.create_next_universe(); + delegate.create_next_universe(); } let var_values = response.value.var_values(); @@ -290,13 +290,13 @@ where } } - let var_values = infcx.interner().mk_args_from_iter( + let var_values = delegate.cx().mk_args_from_iter( response.variables.into_iter().enumerate().map(|(index, info)| { if info.universe() != ty::UniverseIndex::ROOT { // A variable from inside a binder of the query. While ideally these shouldn't // exist at all (see the FIXME at the start of this method), we have to deal with // them for now. - infcx.instantiate_canonical_var_with_infer(info, |idx| { + delegate.instantiate_canonical_var_with_infer(info, |idx| { ty::UniverseIndex::from(prev_universe.index() + idx.index()) }) } else if info.is_existential() { @@ -310,7 +310,7 @@ where if let Some(v) = opt_values[ty::BoundVar::from_usize(index)] { v } else { - infcx.instantiate_canonical_var_with_infer(info, |_| prev_universe) + delegate.instantiate_canonical_var_with_infer(info, |_| prev_universe) } } else { // For placeholders which were already part of the input, we simply map this @@ -335,9 +335,9 @@ where /// whether an alias is rigid by using the trait solver. When instantiating a response /// from the solver we assume that the solver correctly handled aliases and therefore /// always relate them structurally here. - #[instrument(level = "trace", skip(infcx))] + #[instrument(level = "trace", skip(delegate))] fn unify_query_var_values( - infcx: &Infcx, + delegate: &D, param_env: I::ParamEnv, original_values: &[I::GenericArg], var_values: CanonicalVarValues, @@ -345,7 +345,8 @@ where assert_eq!(original_values.len(), var_values.len()); for (&orig, response) in iter::zip(original_values, var_values.var_values) { - let goals = infcx.eq_structurally_relating_aliases(param_env, orig, response).unwrap(); + let goals = + delegate.eq_structurally_relating_aliases(param_env, orig, response).unwrap(); assert!(goals.is_empty()); } } @@ -365,7 +366,7 @@ where fn register_new_opaque_types(&mut self, opaque_types: &[(ty::OpaqueTypeKey, I::Ty)]) { for &(key, ty) in opaque_types { - self.infcx.inject_new_hidden_type_unchecked(key, ty); + self.delegate.inject_new_hidden_type_unchecked(key, ty); } } } @@ -374,22 +375,22 @@ where /// evaluating a goal. The `var_values` not only include the bound variables /// of the query input, but also contain all unconstrained inference vars /// created while evaluating this goal. -pub(in crate::solve) fn make_canonical_state( - infcx: &Infcx, +pub(in crate::solve) fn make_canonical_state( + delegate: &D, var_values: &[I::GenericArg], max_input_universe: ty::UniverseIndex, data: T, ) -> inspect::CanonicalState where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, T: TypeFoldable, { - let var_values = CanonicalVarValues { var_values: infcx.interner().mk_args(var_values) }; + let var_values = CanonicalVarValues { var_values: delegate.cx().mk_args(var_values) }; let state = inspect::State { var_values, data }; - let state = state.fold_with(&mut EagerResolver::new(infcx)); + let state = state.fold_with(&mut EagerResolver::new(delegate)); Canonicalizer::canonicalize( - infcx, + delegate, CanonicalizeMode::Response { max_input_universe }, &mut vec![], state, @@ -398,15 +399,15 @@ where // FIXME: needs to be pub to be accessed by downstream // `rustc_trait_selection::solve::inspect::analyse`. -pub fn instantiate_canonical_state>( - infcx: &Infcx, - span: Infcx::Span, +pub fn instantiate_canonical_state>( + delegate: &D, + span: D::Span, param_env: I::ParamEnv, orig_values: &mut Vec, state: inspect::CanonicalState, ) -> T where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { // In case any fresh inference variables have been created between `state` @@ -415,15 +416,15 @@ where for &arg in &state.value.var_values.var_values[orig_values.len()..state.value.var_values.len()] { // FIXME: This is so ugly. - let unconstrained = infcx.fresh_var_for_kind_with_span(arg, span); + let unconstrained = delegate.fresh_var_for_kind_with_span(arg, span); orig_values.push(unconstrained); } let instantiation = - EvalCtxt::compute_query_response_instantiation_values(infcx, orig_values, &state); + EvalCtxt::compute_query_response_instantiation_values(delegate, orig_values, &state); - let inspect::State { var_values, data } = infcx.instantiate_canonical(state, instantiation); + let inspect::State { var_values, data } = delegate.instantiate_canonical(state, instantiation); - EvalCtxt::unify_query_var_values(infcx, param_env, orig_values, var_values); + EvalCtxt::unify_query_var_values(delegate, param_env, orig_values, var_values); data } diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs index 8548c647b6b1e..6644fff2140c7 100644 --- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs +++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs @@ -11,7 +11,7 @@ use rustc_type_ir::{self as ty, CanonicalVarValues, Interner}; use rustc_type_ir_macros::{Lift_Generic, TypeFoldable_Generic, TypeVisitable_Generic}; use tracing::{instrument, trace}; -use crate::infcx::SolverDelegate; +use crate::delegate::SolverDelegate; use crate::solve::inspect::{self, ProofTreeBuilder}; use crate::solve::search_graph::SearchGraph; use crate::solve::{ @@ -23,9 +23,9 @@ use crate::solve::{ pub(super) mod canonical; mod probe; -pub struct EvalCtxt<'a, Infcx, I = ::Interner> +pub struct EvalCtxt<'a, D, I = ::Interner> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { /// The inference context that backs (mostly) inference and placeholder terms @@ -43,7 +43,7 @@ where /// If some `InferCtxt` method is missing, please first think defensively about /// the method's compatibility with this solver, or if an existing one does /// the job already. - infcx: &'a Infcx, + delegate: &'a D, /// The variable info for the `var_values`, only used to make an ambiguous response /// with no constraints. @@ -83,7 +83,7 @@ where // evaluation code. tainted: Result<(), NoSolution>, - pub(super) inspect: ProofTreeBuilder, + pub(super) inspect: ProofTreeBuilder, } #[derive(derivative::Derivative)] @@ -143,9 +143,9 @@ pub trait SolverDelegateEvalExt: SolverDelegate { ); } -impl SolverDelegateEvalExt for Infcx +impl SolverDelegateEvalExt for D where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { /// Evaluates a goal from **outside** of the trait solver. @@ -178,9 +178,9 @@ where } } -impl<'a, Infcx, I> EvalCtxt<'a, Infcx> +impl<'a, D, I> EvalCtxt<'a, D> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { pub(super) fn solver_mode(&self) -> SolverMode { @@ -195,22 +195,22 @@ where /// used from outside of any evaluation, and other methods should be preferred /// over using this manually (such as [`SolverDelegateEvalExt::evaluate_root_goal`]). pub(super) fn enter_root( - infcx: &Infcx, + delegate: &D, generate_proof_tree: GenerateProofTree, - f: impl FnOnce(&mut EvalCtxt<'_, Infcx>) -> R, + f: impl FnOnce(&mut EvalCtxt<'_, D>) -> R, ) -> (R, Option>) { - let mut search_graph = search_graph::SearchGraph::new(infcx.solver_mode()); + let mut search_graph = search_graph::SearchGraph::new(delegate.solver_mode()); let mut ecx = EvalCtxt { - infcx, + delegate, search_graph: &mut search_graph, nested_goals: NestedGoals::new(), inspect: ProofTreeBuilder::new_maybe_root(generate_proof_tree), // Only relevant when canonicalizing the response, // which we don't do within this evaluation context. - predefined_opaques_in_body: infcx - .interner() + predefined_opaques_in_body: delegate + .cx() .mk_predefined_opaques_in_body(PredefinedOpaquesData::default()), max_input_universe: ty::UniverseIndex::ROOT, variables: Default::default(), @@ -242,14 +242,14 @@ where tcx: I, search_graph: &'a mut search_graph::SearchGraph, canonical_input: CanonicalInput, - canonical_goal_evaluation: &mut ProofTreeBuilder, - f: impl FnOnce(&mut EvalCtxt<'_, Infcx>, Goal) -> R, + canonical_goal_evaluation: &mut ProofTreeBuilder, + f: impl FnOnce(&mut EvalCtxt<'_, D>, Goal) -> R, ) -> R { - let (ref infcx, input, var_values) = + let (ref delegate, input, var_values) = SolverDelegate::build_with_canonical(tcx, search_graph.solver_mode(), &canonical_input); let mut ecx = EvalCtxt { - infcx, + delegate, variables: canonical_input.variables, var_values, is_normalizes_to_goal: false, @@ -262,7 +262,7 @@ where }; for &(key, ty) in &input.predefined_opaques_in_body.opaque_types { - ecx.infcx.inject_new_hidden_type_unchecked(key, ty); + ecx.delegate.inject_new_hidden_type_unchecked(key, ty); } if !ecx.nested_goals.is_empty() { @@ -270,7 +270,7 @@ where } let result = f(&mut ecx, input.goal); - ecx.inspect.probe_final_state(ecx.infcx, ecx.max_input_universe); + ecx.inspect.probe_final_state(ecx.delegate, ecx.max_input_universe); canonical_goal_evaluation.goal_evaluation_step(ecx.inspect); // When creating a query response we clone the opaque type constraints @@ -278,7 +278,7 @@ where // assertions against dropping an `InferCtxt` without taking opaques. // FIXME: Once we remove support for the old impl we can remove this. // FIXME: Could we make `build_with_canonical` into `enter_with_canonical` and call this at the end? - infcx.reset_opaque_types(); + delegate.reset_opaque_types(); result } @@ -297,7 +297,7 @@ where tcx: I, search_graph: &'a mut search_graph::SearchGraph, canonical_input: CanonicalInput, - goal_evaluation: &mut ProofTreeBuilder, + goal_evaluation: &mut ProofTreeBuilder, ) -> QueryResult { let mut canonical_goal_evaluation = goal_evaluation.new_canonical_goal_evaluation(canonical_input); @@ -364,7 +364,7 @@ where let mut goal_evaluation = self.inspect.new_goal_evaluation(goal, &orig_values, goal_evaluation_kind); let canonical_response = EvalCtxt::evaluate_canonical_goal( - self.interner(), + self.cx(), self.search_graph, canonical_goal, &mut goal_evaluation, @@ -466,8 +466,8 @@ where } } } else { - self.infcx.enter_forall(kind, |kind| { - let goal = goal.with(self.interner(), ty::Binder::dummy(kind)); + self.delegate.enter_forall(kind, |kind| { + let goal = goal.with(self.cx(), ty::Binder::dummy(kind)); self.add_goal(GoalSource::InstantiateHigherRanked, goal); self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes) }) @@ -506,7 +506,7 @@ where /// /// Goals for the next step get directly added to the nested goals of the `EvalCtxt`. fn evaluate_added_goals_step(&mut self) -> Result, NoSolution> { - let tcx = self.interner(); + let tcx = self.cx(); let mut goals = core::mem::take(&mut self.nested_goals); // If this loop did not result in any progress, what's our final certainty. @@ -588,11 +588,11 @@ where /// Record impl args in the proof tree for later access by `InspectCandidate`. pub(crate) fn record_impl_args(&mut self, impl_args: I::GenericArgs) { - self.inspect.record_impl_args(self.infcx, self.max_input_universe, impl_args) + self.inspect.record_impl_args(self.delegate, self.max_input_universe, impl_args) } - pub(super) fn interner(&self) -> I { - self.infcx.interner() + pub(super) fn cx(&self) -> I { + self.delegate.cx() } #[instrument(level = "trace", skip(self))] @@ -600,7 +600,7 @@ where goal.predicate = goal .predicate .fold_with(&mut ReplaceAliasWithInfer { ecx: self, param_env: goal.param_env }); - self.inspect.add_normalizes_to_goal(self.infcx, self.max_input_universe, goal); + self.inspect.add_normalizes_to_goal(self.delegate, self.max_input_universe, goal); self.nested_goals.normalizes_to_goals.push(goal); } @@ -609,7 +609,7 @@ where goal.predicate = goal .predicate .fold_with(&mut ReplaceAliasWithInfer { ecx: self, param_env: goal.param_env }); - self.inspect.add_goal(self.infcx, self.max_input_universe, source, goal); + self.inspect.add_goal(self.delegate, self.max_input_universe, source, goal); self.nested_goals.goals.push((source, goal)); } @@ -625,13 +625,13 @@ where } pub(super) fn next_ty_infer(&mut self) -> I::Ty { - let ty = self.infcx.next_ty_infer(); + let ty = self.delegate.next_ty_infer(); self.inspect.add_var_value(ty); ty } pub(super) fn next_const_infer(&mut self) -> I::Const { - let ct = self.infcx.next_const_infer(); + let ct = self.delegate.next_const_infer(); self.inspect.add_var_value(ct); ct } @@ -654,27 +654,27 @@ where let universe_of_term = match goal.predicate.term.kind() { ty::TermKind::Ty(ty) => { if let ty::Infer(ty::TyVar(vid)) = ty.kind() { - self.infcx.universe_of_ty(vid).unwrap() + self.delegate.universe_of_ty(vid).unwrap() } else { return false; } } ty::TermKind::Const(ct) => { if let ty::ConstKind::Infer(ty::InferConst::Var(vid)) = ct.kind() { - self.infcx.universe_of_ct(vid).unwrap() + self.delegate.universe_of_ct(vid).unwrap() } else { return false; } } }; - struct ContainsTermOrNotNameable<'a, Infcx: SolverDelegate, I: Interner> { + struct ContainsTermOrNotNameable<'a, D: SolverDelegate, I: Interner> { term: I::Term, universe_of_term: ty::UniverseIndex, - infcx: &'a Infcx, + delegate: &'a D, } - impl, I: Interner> ContainsTermOrNotNameable<'_, Infcx, I> { + impl, I: Interner> ContainsTermOrNotNameable<'_, D, I> { fn check_nameable(&self, universe: ty::UniverseIndex) -> ControlFlow<()> { if self.universe_of_term.can_name(universe) { ControlFlow::Continue(()) @@ -684,8 +684,8 @@ where } } - impl, I: Interner> TypeVisitor - for ContainsTermOrNotNameable<'_, Infcx, I> + impl, I: Interner> TypeVisitor + for ContainsTermOrNotNameable<'_, D, I> { type Result = ControlFlow<()>; fn visit_ty(&mut self, t: I::Ty) -> Self::Result { @@ -693,13 +693,15 @@ where ty::Infer(ty::TyVar(vid)) => { if let ty::TermKind::Ty(term) = self.term.kind() { if let ty::Infer(ty::TyVar(term_vid)) = term.kind() { - if self.infcx.root_ty_var(vid) == self.infcx.root_ty_var(term_vid) { + if self.delegate.root_ty_var(vid) + == self.delegate.root_ty_var(term_vid) + { return ControlFlow::Break(()); } } } - self.check_nameable(self.infcx.universe_of_ty(vid).unwrap()) + self.check_nameable(self.delegate.universe_of_ty(vid).unwrap()) } ty::Placeholder(p) => self.check_nameable(p.universe()), _ => { @@ -718,15 +720,15 @@ where if let ty::TermKind::Const(term) = self.term.kind() { if let ty::ConstKind::Infer(ty::InferConst::Var(term_vid)) = term.kind() { - if self.infcx.root_const_var(vid) - == self.infcx.root_const_var(term_vid) + if self.delegate.root_const_var(vid) + == self.delegate.root_const_var(term_vid) { return ControlFlow::Break(()); } } } - self.check_nameable(self.infcx.universe_of_ct(vid).unwrap()) + self.check_nameable(self.delegate.universe_of_ct(vid).unwrap()) } ty::ConstKind::Placeholder(p) => self.check_nameable(p.universe()), _ => { @@ -741,7 +743,7 @@ where } let mut visitor = ContainsTermOrNotNameable { - infcx: self.infcx, + delegate: self.delegate, universe_of_term, term: goal.predicate.term, }; @@ -775,7 +777,7 @@ where // NOTE: this check is purely an optimization, the structural eq would // always fail if the term is not an inference variable. if term.is_infer() { - let tcx = self.interner(); + let tcx = self.cx(); // We need to relate `alias` to `term` treating only the outermost // constructor as rigid, relating any contained generic arguments as // normal. We do this by first structurally equating the `term` @@ -788,7 +790,7 @@ where let rigid_ctor = ty::AliasTerm::new(tcx, alias.def_id, identity_args); let ctor_term = rigid_ctor.to_term(tcx); let obligations = - self.infcx.eq_structurally_relating_aliases(param_env, term, ctor_term)?; + self.delegate.eq_structurally_relating_aliases(param_env, term, ctor_term)?; debug_assert!(obligations.is_empty()); self.relate(param_env, alias, variance, rigid_ctor) } else { @@ -806,7 +808,7 @@ where lhs: T, rhs: T, ) -> Result<(), NoSolution> { - let result = self.infcx.eq_structurally_relating_aliases(param_env, lhs, rhs)?; + let result = self.delegate.eq_structurally_relating_aliases(param_env, lhs, rhs)?; assert_eq!(result, vec![]); Ok(()) } @@ -829,7 +831,7 @@ where variance: ty::Variance, rhs: T, ) -> Result<(), NoSolution> { - let goals = self.infcx.relate(param_env, lhs, variance, rhs)?; + let goals = self.delegate.relate(param_env, lhs, variance, rhs)?; self.add_goals(GoalSource::Misc, goals); Ok(()) } @@ -846,14 +848,14 @@ where lhs: T, rhs: T, ) -> Result>, NoSolution> { - self.infcx.relate(param_env, lhs, ty::Variance::Invariant, rhs) + self.delegate.relate(param_env, lhs, ty::Variance::Invariant, rhs) } pub(super) fn instantiate_binder_with_infer + Copy>( &self, value: ty::Binder, ) -> T { - self.infcx.instantiate_binder_with_infer(value) + self.delegate.instantiate_binder_with_infer(value) } pub(super) fn enter_forall + Copy, U>( @@ -861,18 +863,18 @@ where value: ty::Binder, f: impl FnOnce(T) -> U, ) -> U { - self.infcx.enter_forall(value, f) + self.delegate.enter_forall(value, f) } pub(super) fn resolve_vars_if_possible(&self, value: T) -> T where T: TypeFoldable, { - self.infcx.resolve_vars_if_possible(value) + self.delegate.resolve_vars_if_possible(value) } pub(super) fn fresh_args_for_item(&mut self, def_id: I::DefId) -> I::GenericArgs { - let args = self.infcx.fresh_args_for_item(def_id); + let args = self.delegate.fresh_args_for_item(def_id); for arg in args { self.inspect.add_var_value(arg); } @@ -880,12 +882,12 @@ where } pub(super) fn register_ty_outlives(&self, ty: I::Ty, lt: I::Region) { - self.infcx.register_ty_outlives(ty, lt); + self.delegate.register_ty_outlives(ty, lt); } pub(super) fn register_region_outlives(&self, a: I::Region, b: I::Region) { // `b : a` ==> `a <= b` - self.infcx.sub_regions(b, a); + self.delegate.sub_regions(b, a); } /// Computes the list of goals required for `arg` to be well-formed @@ -894,7 +896,7 @@ where param_env: I::ParamEnv, arg: I::GenericArg, ) -> Option>> { - self.infcx.well_formed_goals(param_env, arg) + self.delegate.well_formed_goals(param_env, arg) } pub(super) fn trait_ref_is_knowable( @@ -902,9 +904,9 @@ where param_env: I::ParamEnv, trait_ref: ty::TraitRef, ) -> Result { - let infcx = self.infcx; + let delegate = self.delegate; let lazily_normalize_ty = |ty| self.structurally_normalize_ty(param_env, ty); - infcx.trait_ref_is_knowable(trait_ref, lazily_normalize_ty) + delegate.trait_ref_is_knowable(trait_ref, lazily_normalize_ty) } pub(super) fn fetch_eligible_assoc_item( @@ -914,7 +916,7 @@ where trait_assoc_def_id: I::DefId, impl_def_id: I::DefId, ) -> Result, NoSolution> { - self.infcx.fetch_eligible_assoc_item( + self.delegate.fetch_eligible_assoc_item( param_env, goal_trait_ref, trait_assoc_def_id, @@ -923,7 +925,7 @@ where } pub(super) fn can_define_opaque_ty(&self, def_id: I::LocalDefId) -> bool { - self.infcx.defining_opaque_types().contains(&def_id) + self.delegate.defining_opaque_types().contains(&def_id) } pub(super) fn insert_hidden_type( @@ -933,7 +935,7 @@ where hidden_ty: I::Ty, ) -> Result<(), NoSolution> { let mut goals = Vec::new(); - self.infcx.insert_hidden_type(opaque_type_key, param_env, hidden_ty, &mut goals)?; + self.delegate.insert_hidden_type(opaque_type_key, param_env, hidden_ty, &mut goals)?; self.add_goals(GoalSource::Misc, goals); Ok(()) } @@ -946,7 +948,7 @@ where hidden_ty: I::Ty, ) { let mut goals = Vec::new(); - self.infcx.add_item_bounds_for_hidden_type( + self.delegate.add_item_bounds_for_hidden_type( opaque_def_id, opaque_args, param_env, @@ -965,7 +967,7 @@ where ty: I::Ty, ) -> Vec> { // FIXME: Super inefficient to be cloning this... - let opaques = self.infcx.clone_opaque_types_for_query_response(); + let opaques = self.delegate.clone_opaque_types_for_query_response(); let mut values = vec![]; for (candidate_key, candidate_ty) in opaques { @@ -1002,7 +1004,7 @@ where param_env: I::ParamEnv, unevaluated: ty::UnevaluatedConst, ) -> Option { - self.infcx.try_const_eval_resolve(param_env, unevaluated) + self.delegate.try_const_eval_resolve(param_env, unevaluated) } pub(super) fn is_transmutable( @@ -1012,7 +1014,7 @@ where src: I::Ty, assume: I::Const, ) -> Result { - self.infcx.is_transmutable(param_env, dst, src, assume) + self.delegate.is_transmutable(param_env, dst, src, assume) } } @@ -1023,22 +1025,22 @@ where /// /// This is a performance optimization to more eagerly detect cycles during trait /// solving. See tests/ui/traits/next-solver/cycles/cycle-modulo-ambig-aliases.rs. -struct ReplaceAliasWithInfer<'me, 'a, Infcx, I> +struct ReplaceAliasWithInfer<'me, 'a, D, I> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { - ecx: &'me mut EvalCtxt<'a, Infcx>, + ecx: &'me mut EvalCtxt<'a, D>, param_env: I::ParamEnv, } -impl TypeFolder for ReplaceAliasWithInfer<'_, '_, Infcx, I> +impl TypeFolder for ReplaceAliasWithInfer<'_, '_, D, I> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { - fn interner(&self) -> I { - self.ecx.interner() + fn cx(&self) -> I { + self.ecx.cx() } fn fold_ty(&mut self, ty: I::Ty) -> I::Ty { @@ -1052,7 +1054,7 @@ where ); self.ecx.add_goal( GoalSource::Misc, - Goal::new(self.interner(), self.param_env, normalizes_to), + Goal::new(self.cx(), self.param_env, normalizes_to), ); infer_ty } @@ -1071,7 +1073,7 @@ where ); self.ecx.add_goal( GoalSource::Misc, - Goal::new(self.interner(), self.param_env, normalizes_to), + Goal::new(self.cx(), self.param_env, normalizes_to), ); infer_ct } diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/probe.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/probe.rs index 1c5358b3edb4d..e9516c60c70f9 100644 --- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/probe.rs +++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/probe.rs @@ -3,34 +3,34 @@ use std::marker::PhantomData; use rustc_type_ir::Interner; use tracing::instrument; -use crate::infcx::SolverDelegate; +use crate::delegate::SolverDelegate; use crate::solve::assembly::Candidate; use crate::solve::inspect; use crate::solve::{BuiltinImplSource, CandidateSource, EvalCtxt, NoSolution, QueryResult}; -pub(in crate::solve) struct ProbeCtxt<'me, 'a, Infcx, I, F, T> +pub(in crate::solve) struct ProbeCtxt<'me, 'a, D, I, F, T> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { - ecx: &'me mut EvalCtxt<'a, Infcx, I>, + ecx: &'me mut EvalCtxt<'a, D, I>, probe_kind: F, _result: PhantomData, } -impl ProbeCtxt<'_, '_, Infcx, I, F, T> +impl ProbeCtxt<'_, '_, D, I, F, T> where F: FnOnce(&T) -> inspect::ProbeKind, - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { - pub(in crate::solve) fn enter(self, f: impl FnOnce(&mut EvalCtxt<'_, Infcx>) -> T) -> T { + pub(in crate::solve) fn enter(self, f: impl FnOnce(&mut EvalCtxt<'_, D>) -> T) -> T { let ProbeCtxt { ecx: outer_ecx, probe_kind, _result } = self; - let infcx = outer_ecx.infcx; + let delegate = outer_ecx.delegate; let max_input_universe = outer_ecx.max_input_universe; let mut nested_ecx = EvalCtxt { - infcx, + delegate, variables: outer_ecx.variables, var_values: outer_ecx.var_values, is_normalizes_to_goal: outer_ecx.is_normalizes_to_goal, @@ -41,9 +41,9 @@ where tainted: outer_ecx.tainted, inspect: outer_ecx.inspect.take_and_enter_probe(), }; - let r = nested_ecx.infcx.probe(|| { + let r = nested_ecx.delegate.probe(|| { let r = f(&mut nested_ecx); - nested_ecx.inspect.probe_final_state(infcx, max_input_universe); + nested_ecx.inspect.probe_final_state(delegate, max_input_universe); r }); if !nested_ecx.inspect.is_noop() { @@ -55,41 +55,38 @@ where } } -pub(in crate::solve) struct TraitProbeCtxt<'me, 'a, Infcx, I, F> +pub(in crate::solve) struct TraitProbeCtxt<'me, 'a, D, I, F> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { - cx: ProbeCtxt<'me, 'a, Infcx, I, F, QueryResult>, + cx: ProbeCtxt<'me, 'a, D, I, F, QueryResult>, source: CandidateSource, } -impl TraitProbeCtxt<'_, '_, Infcx, I, F> +impl TraitProbeCtxt<'_, '_, D, I, F> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, F: FnOnce(&QueryResult) -> inspect::ProbeKind, { #[instrument(level = "debug", skip_all, fields(source = ?self.source))] pub(in crate::solve) fn enter( self, - f: impl FnOnce(&mut EvalCtxt<'_, Infcx>) -> QueryResult, + f: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult, ) -> Result, NoSolution> { self.cx.enter(|ecx| f(ecx)).map(|result| Candidate { source: self.source, result }) } } -impl<'a, Infcx, I> EvalCtxt<'a, Infcx, I> +impl<'a, D, I> EvalCtxt<'a, D, I> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { /// `probe_kind` is only called when proof tree building is enabled so it can be /// as expensive as necessary to output the desired information. - pub(in crate::solve) fn probe( - &mut self, - probe_kind: F, - ) -> ProbeCtxt<'_, 'a, Infcx, I, F, T> + pub(in crate::solve) fn probe(&mut self, probe_kind: F) -> ProbeCtxt<'_, 'a, D, I, F, T> where F: FnOnce(&T) -> inspect::ProbeKind, { @@ -99,16 +96,14 @@ where pub(in crate::solve) fn probe_builtin_trait_candidate( &mut self, source: BuiltinImplSource, - ) -> TraitProbeCtxt<'_, 'a, Infcx, I, impl FnOnce(&QueryResult) -> inspect::ProbeKind> - { + ) -> TraitProbeCtxt<'_, 'a, D, I, impl FnOnce(&QueryResult) -> inspect::ProbeKind> { self.probe_trait_candidate(CandidateSource::BuiltinImpl(source)) } pub(in crate::solve) fn probe_trait_candidate( &mut self, source: CandidateSource, - ) -> TraitProbeCtxt<'_, 'a, Infcx, I, impl FnOnce(&QueryResult) -> inspect::ProbeKind> - { + ) -> TraitProbeCtxt<'_, 'a, D, I, impl FnOnce(&QueryResult) -> inspect::ProbeKind> { TraitProbeCtxt { cx: ProbeCtxt { ecx: self, diff --git a/compiler/rustc_next_trait_solver/src/solve/inspect/build.rs b/compiler/rustc_next_trait_solver/src/solve/inspect/build.rs index 5fbec4b28d434..ae59f0c5e9572 100644 --- a/compiler/rustc_next_trait_solver/src/solve/inspect/build.rs +++ b/compiler/rustc_next_trait_solver/src/solve/inspect/build.rs @@ -9,7 +9,7 @@ use std::mem; use rustc_type_ir::{self as ty, Interner}; -use crate::infcx::SolverDelegate; +use crate::delegate::SolverDelegate; use crate::solve::eval_ctxt::canonical; use crate::solve::inspect; use crate::solve::{ @@ -37,12 +37,12 @@ use crate::solve::{ /// trees. At the end of trait solving `ProofTreeBuilder::finalize` /// is called to recursively convert the whole structure to a /// finished proof tree. -pub(in crate::solve) struct ProofTreeBuilder::Interner> +pub(in crate::solve) struct ProofTreeBuilder::Interner> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { - _infcx: PhantomData, + _infcx: PhantomData, state: Option>>, } @@ -235,8 +235,8 @@ impl WipProbeStep { } } -impl, I: Interner> ProofTreeBuilder { - fn new(state: impl Into>) -> ProofTreeBuilder { +impl, I: Interner> ProofTreeBuilder { + fn new(state: impl Into>) -> ProofTreeBuilder { ProofTreeBuilder { state: Some(Box::new(state.into())), _infcx: PhantomData } } @@ -258,7 +258,7 @@ impl, I: Interner> ProofTreeBuilder { self.state.as_deref_mut() } - pub fn take_and_enter_probe(&mut self) -> ProofTreeBuilder { + pub fn take_and_enter_probe(&mut self) -> ProofTreeBuilder { let mut nested = ProofTreeBuilder { state: self.state.take(), _infcx: PhantomData }; nested.enter_probe(); nested @@ -273,18 +273,18 @@ impl, I: Interner> ProofTreeBuilder { } } - pub fn new_maybe_root(generate_proof_tree: GenerateProofTree) -> ProofTreeBuilder { + pub fn new_maybe_root(generate_proof_tree: GenerateProofTree) -> ProofTreeBuilder { match generate_proof_tree { GenerateProofTree::No => ProofTreeBuilder::new_noop(), GenerateProofTree::Yes => ProofTreeBuilder::new_root(), } } - pub fn new_root() -> ProofTreeBuilder { + pub fn new_root() -> ProofTreeBuilder { ProofTreeBuilder::new(DebugSolver::Root) } - pub fn new_noop() -> ProofTreeBuilder { + pub fn new_noop() -> ProofTreeBuilder { ProofTreeBuilder { state: None, _infcx: PhantomData } } @@ -297,7 +297,7 @@ impl, I: Interner> ProofTreeBuilder { goal: Goal, orig_values: &[I::GenericArg], kind: GoalEvaluationKind, - ) -> ProofTreeBuilder { + ) -> ProofTreeBuilder { self.opt_nested(|| match kind { GoalEvaluationKind::Root => Some(WipGoalEvaluation { uncanonicalized_goal: goal, @@ -311,7 +311,7 @@ impl, I: Interner> ProofTreeBuilder { pub fn new_canonical_goal_evaluation( &mut self, goal: CanonicalInput, - ) -> ProofTreeBuilder { + ) -> ProofTreeBuilder { self.nested(|| WipCanonicalGoalEvaluation { goal, kind: None, @@ -337,10 +337,7 @@ impl, I: Interner> ProofTreeBuilder { }) } - pub fn canonical_goal_evaluation( - &mut self, - canonical_goal_evaluation: ProofTreeBuilder, - ) { + pub fn canonical_goal_evaluation(&mut self, canonical_goal_evaluation: ProofTreeBuilder) { if let Some(this) = self.as_mut() { match (this, *canonical_goal_evaluation.state.unwrap()) { ( @@ -366,7 +363,7 @@ impl, I: Interner> ProofTreeBuilder { } } - pub fn goal_evaluation(&mut self, goal_evaluation: ProofTreeBuilder) { + pub fn goal_evaluation(&mut self, goal_evaluation: ProofTreeBuilder) { if let Some(this) = self.as_mut() { match this { DebugSolver::Root => *this = *goal_evaluation.state.unwrap(), @@ -382,7 +379,7 @@ impl, I: Interner> ProofTreeBuilder { &mut self, var_values: ty::CanonicalVarValues, instantiated_goal: QueryInput, - ) -> ProofTreeBuilder { + ) -> ProofTreeBuilder { self.nested(|| WipCanonicalGoalEvaluationStep { var_values: var_values.var_values.to_vec(), instantiated_goal, @@ -396,7 +393,7 @@ impl, I: Interner> ProofTreeBuilder { }) } - pub fn goal_evaluation_step(&mut self, goal_evaluation_step: ProofTreeBuilder) { + pub fn goal_evaluation_step(&mut self, goal_evaluation_step: ProofTreeBuilder) { if let Some(this) = self.as_mut() { match (this, *goal_evaluation_step.state.unwrap()) { ( @@ -448,12 +445,12 @@ impl, I: Interner> ProofTreeBuilder { } } - pub fn probe_final_state(&mut self, infcx: &Infcx, max_input_universe: ty::UniverseIndex) { + pub fn probe_final_state(&mut self, delegate: &D, max_input_universe: ty::UniverseIndex) { match self.as_mut() { None => {} Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => { let final_state = canonical::make_canonical_state( - infcx, + delegate, &state.var_values, max_input_universe, (), @@ -467,21 +464,21 @@ impl, I: Interner> ProofTreeBuilder { pub fn add_normalizes_to_goal( &mut self, - infcx: &Infcx, + delegate: &D, max_input_universe: ty::UniverseIndex, goal: Goal>, ) { self.add_goal( - infcx, + delegate, max_input_universe, GoalSource::Misc, - goal.with(infcx.interner(), goal.predicate), + goal.with(delegate.cx(), goal.predicate), ); } pub fn add_goal( &mut self, - infcx: &Infcx, + delegate: &D, max_input_universe: ty::UniverseIndex, source: GoalSource, goal: Goal, @@ -490,7 +487,7 @@ impl, I: Interner> ProofTreeBuilder { None => {} Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => { let goal = canonical::make_canonical_state( - infcx, + delegate, &state.var_values, max_input_universe, goal, @@ -503,14 +500,14 @@ impl, I: Interner> ProofTreeBuilder { pub(crate) fn record_impl_args( &mut self, - infcx: &Infcx, + delegate: &D, max_input_universe: ty::UniverseIndex, impl_args: I::GenericArgs, ) { match self.as_mut() { Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => { let impl_args = canonical::make_canonical_state( - infcx, + delegate, &state.var_values, max_input_universe, impl_args, @@ -538,7 +535,7 @@ impl, I: Interner> ProofTreeBuilder { } } - pub fn finish_probe(mut self) -> ProofTreeBuilder { + pub fn finish_probe(mut self) -> ProofTreeBuilder { match self.as_mut() { None => {} Some(DebugSolver::CanonicalGoalEvaluationStep(state)) => { diff --git a/compiler/rustc_next_trait_solver/src/solve/mod.rs b/compiler/rustc_next_trait_solver/src/solve/mod.rs index 02069016c2bde..b76b4c098523e 100644 --- a/compiler/rustc_next_trait_solver/src/solve/mod.rs +++ b/compiler/rustc_next_trait_solver/src/solve/mod.rs @@ -29,7 +29,7 @@ use rustc_type_ir::{self as ty, Interner}; use tracing::instrument; pub use self::eval_ctxt::{EvalCtxt, GenerateProofTree, SolverDelegateEvalExt}; -use crate::infcx::SolverDelegate; +use crate::delegate::SolverDelegate; /// How many fixpoint iterations we should attempt inside of the solver before bailing /// with overflow. @@ -56,9 +56,9 @@ fn has_no_inference_or_external_constraints( && response.value.external_constraints.opaque_types.is_empty() } -impl<'a, Infcx, I> EvalCtxt<'a, Infcx> +impl<'a, D, I> EvalCtxt<'a, D> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { #[instrument(level = "trace", skip(self))] @@ -104,7 +104,7 @@ where } fn compute_object_safe_goal(&mut self, trait_def_id: I::DefId) -> QueryResult { - if self.interner().trait_is_object_safe(trait_def_id) { + if self.cx().trait_is_object_safe(trait_def_id) { self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes) } else { Err(NoSolution) @@ -182,7 +182,7 @@ where return self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes); } ty::ConstKind::Unevaluated(uv) => { - self.interner().type_of(uv.def).instantiate(self.interner(), &uv.args) + self.cx().type_of(uv.def).instantiate(self.cx(), &uv.args) } ty::ConstKind::Expr(_) => unimplemented!( "`feature(generic_const_exprs)` is not supported in the new trait solver" @@ -193,7 +193,7 @@ where ty::ConstKind::Bound(_, _) => panic!("escaping bound vars in {:?}", ct), ty::ConstKind::Value(ty, _) => ty, ty::ConstKind::Placeholder(placeholder) => { - self.interner().find_const_ty_from_env(goal.param_env, placeholder) + self.cx().find_const_ty_from_env(goal.param_env, placeholder) } }; @@ -202,9 +202,9 @@ where } } -impl EvalCtxt<'_, Infcx> +impl EvalCtxt<'_, D> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { /// Try to merge multiple possible ways to prove a goal, if that is not possible returns `None`. @@ -267,7 +267,7 @@ where if let ty::Alias(..) = ty.kind() { let normalized_ty = self.next_ty_infer(); let alias_relate_goal = Goal::new( - self.interner(), + self.cx(), param_env, ty::PredicateKind::AliasRelate( ty.into(), diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/anon_const.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/anon_const.rs index 0f1c1f13c165e..5d5597429da45 100644 --- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/anon_const.rs +++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/anon_const.rs @@ -1,12 +1,12 @@ use rustc_type_ir::{self as ty, Interner}; use tracing::instrument; -use crate::infcx::SolverDelegate; +use crate::delegate::SolverDelegate; use crate::solve::{Certainty, EvalCtxt, Goal, QueryResult}; -impl EvalCtxt<'_, Infcx> +impl EvalCtxt<'_, D> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { #[instrument(level = "trace", skip(self), ret)] diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/inherent.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/inherent.rs index 8436f3ad48417..827fe5f2ca405 100644 --- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/inherent.rs +++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/inherent.rs @@ -7,19 +7,19 @@ use rustc_type_ir::{self as ty, Interner}; -use crate::infcx::SolverDelegate; +use crate::delegate::SolverDelegate; use crate::solve::{Certainty, EvalCtxt, Goal, GoalSource, QueryResult}; -impl EvalCtxt<'_, Infcx> +impl EvalCtxt<'_, D> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { pub(super) fn normalize_inherent_associated_type( &mut self, goal: Goal>, ) -> QueryResult { - let tcx = self.interner(); + let tcx = self.cx(); let inherent = goal.predicate.alias.expect_ty(tcx); let impl_def_id = tcx.parent(inherent.def_id); 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 index ebc83bef5137b..f58384d86cd68 100644 --- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs +++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs @@ -9,7 +9,7 @@ use rustc_type_ir::Upcast as _; use rustc_type_ir::{self as ty, Interner, NormalizesTo}; use tracing::instrument; -use crate::infcx::SolverDelegate; +use crate::delegate::SolverDelegate; use crate::solve::assembly::structural_traits::{self, AsyncCallableRelevantTypes}; use crate::solve::assembly::{self, Candidate}; use crate::solve::inspect::ProbeKind; @@ -18,9 +18,9 @@ use crate::solve::{ NoSolution, QueryResult, }; -impl EvalCtxt<'_, Infcx> +impl EvalCtxt<'_, D> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { #[instrument(level = "trace", skip(self), ret)] @@ -48,7 +48,7 @@ where /// returns `NoSolution`. #[instrument(level = "trace", skip(self), ret)] fn normalize_at_least_one_step(&mut self, goal: Goal>) -> QueryResult { - match goal.predicate.alias.kind(self.interner()) { + match goal.predicate.alias.kind(self.cx()) { ty::AliasTermKind::ProjectionTy | ty::AliasTermKind::ProjectionConst => { let candidates = self.assemble_and_evaluate_candidates(goal); self.merge_candidates(candidates) @@ -75,9 +75,9 @@ where } } -impl assembly::GoalKind for NormalizesTo +impl assembly::GoalKind for NormalizesTo where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { fn self_ty(self) -> I::Ty { @@ -97,15 +97,15 @@ where } fn probe_and_match_goal_against_assumption( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, source: CandidateSource, goal: Goal, assumption: I::Clause, - then: impl FnOnce(&mut EvalCtxt<'_, Infcx>) -> QueryResult, + then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult, ) -> Result, NoSolution> { if let Some(projection_pred) = assumption.as_projection_clause() { if projection_pred.projection_def_id() == goal.predicate.def_id() { - let tcx = ecx.interner(); + let tcx = ecx.cx(); ecx.probe_trait_candidate(source).enter(|ecx| { let assumption_projection_pred = ecx.instantiate_binder_with_infer(projection_pred); @@ -136,15 +136,15 @@ where } fn consider_impl_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal>, impl_def_id: I::DefId, ) -> Result, NoSolution> { - let tcx = ecx.interner(); + let tcx = ecx.cx(); let goal_trait_ref = goal.predicate.alias.trait_ref(tcx); let impl_trait_ref = tcx.impl_trait_ref(impl_def_id); - if !ecx.interner().args_may_unify_deep( + if !ecx.cx().args_may_unify_deep( goal.predicate.alias.trait_ref(tcx).args, impl_trait_ref.skip_binder().args, ) { @@ -194,7 +194,7 @@ where return ecx.evaluate_added_goals_and_make_canonical_response(Certainty::AMBIGUOUS); }; - let error_response = |ecx: &mut EvalCtxt<'_, Infcx>, msg: &str| { + let error_response = |ecx: &mut EvalCtxt<'_, D>, msg: &str| { let guar = tcx.delay_bug(msg); let error_term = match goal.predicate.alias.kind(tcx) { ty::AliasTermKind::ProjectionTy => Ty::new_error(tcx, guar).into(), @@ -262,61 +262,61 @@ where /// Fail to normalize if the predicate contains an error, alternatively, we could normalize to `ty::Error` /// and succeed. Can experiment with this to figure out what results in better error messages. fn consider_error_guaranteed_candidate( - _ecx: &mut EvalCtxt<'_, Infcx>, + _ecx: &mut EvalCtxt<'_, D>, _guar: I::ErrorGuaranteed, ) -> Result, NoSolution> { Err(NoSolution) } fn consider_auto_trait_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, _goal: Goal, ) -> Result, NoSolution> { - ecx.interner().delay_bug("associated types not allowed on auto traits"); + ecx.cx().delay_bug("associated types not allowed on auto traits"); Err(NoSolution) } fn consider_trait_alias_candidate( - _ecx: &mut EvalCtxt<'_, Infcx>, + _ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { panic!("trait aliases do not have associated types: {:?}", goal); } fn consider_builtin_sized_candidate( - _ecx: &mut EvalCtxt<'_, Infcx>, + _ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { panic!("`Sized` does not have an associated type: {:?}", goal); } fn consider_builtin_copy_clone_candidate( - _ecx: &mut EvalCtxt<'_, Infcx>, + _ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { panic!("`Copy`/`Clone` does not have an associated type: {:?}", goal); } fn consider_builtin_pointer_like_candidate( - _ecx: &mut EvalCtxt<'_, Infcx>, + _ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { panic!("`PointerLike` does not have an associated type: {:?}", goal); } fn consider_builtin_fn_ptr_trait_candidate( - _ecx: &mut EvalCtxt<'_, Infcx>, + _ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { panic!("`FnPtr` does not have an associated type: {:?}", goal); } fn consider_builtin_fn_trait_candidates( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, goal_kind: ty::ClosureKind, ) -> Result, NoSolution> { - let tcx = ecx.interner(); + let tcx = ecx.cx(); let tupled_inputs_and_output = match structural_traits::extract_tupled_inputs_and_output_from_callable( tcx, @@ -355,11 +355,11 @@ where } fn consider_builtin_async_fn_trait_candidates( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, goal_kind: ty::ClosureKind, ) -> Result, NoSolution> { - let tcx = ecx.interner(); + let tcx = ecx.cx(); let env_region = match goal_kind { ty::ClosureKind::Fn | ty::ClosureKind::FnMut => goal.predicate.alias.args.region_at(2), @@ -457,7 +457,7 @@ where } fn consider_builtin_async_fn_kind_helper_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { let [ @@ -489,7 +489,7 @@ where } let upvars_ty = ty::CoroutineClosureSignature::tupled_upvars_by_closure_kind( - ecx.interner(), + ecx.cx(), goal_kind, tupled_inputs_ty.expect_ty(), tupled_upvars_ty.expect_ty(), @@ -504,17 +504,17 @@ where } fn consider_builtin_tuple_candidate( - _ecx: &mut EvalCtxt<'_, Infcx>, + _ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { panic!("`Tuple` does not have an associated type: {:?}", goal); } fn consider_builtin_pointee_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { - let tcx = ecx.interner(); + let tcx = ecx.cx(); let metadata_def_id = tcx.require_lang_item(TraitSolverLangItem::Metadata); assert_eq!(metadata_def_id, goal.predicate.def_id()); ecx.probe_builtin_trait_candidate(BuiltinImplSource::Misc).enter(|ecx| { @@ -592,7 +592,7 @@ where } fn consider_builtin_future_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { let self_ty = goal.predicate.self_ty(); @@ -601,7 +601,7 @@ where }; // Coroutines are not futures unless they come from `async` desugaring - let tcx = ecx.interner(); + let tcx = ecx.cx(); if !tcx.coroutine_is_async(def_id) { return Err(NoSolution); } @@ -613,11 +613,7 @@ where CandidateSource::BuiltinImpl(BuiltinImplSource::Misc), goal, ty::ProjectionPredicate { - projection_term: ty::AliasTerm::new( - ecx.interner(), - goal.predicate.def_id(), - [self_ty], - ), + projection_term: ty::AliasTerm::new(ecx.cx(), goal.predicate.def_id(), [self_ty]), term, } .upcast(tcx), @@ -628,7 +624,7 @@ where } fn consider_builtin_iterator_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { let self_ty = goal.predicate.self_ty(); @@ -637,7 +633,7 @@ where }; // Coroutines are not Iterators unless they come from `gen` desugaring - let tcx = ecx.interner(); + let tcx = ecx.cx(); if !tcx.coroutine_is_gen(def_id) { return Err(NoSolution); } @@ -649,11 +645,7 @@ where CandidateSource::BuiltinImpl(BuiltinImplSource::Misc), goal, ty::ProjectionPredicate { - projection_term: ty::AliasTerm::new( - ecx.interner(), - goal.predicate.def_id(), - [self_ty], - ), + projection_term: ty::AliasTerm::new(ecx.cx(), goal.predicate.def_id(), [self_ty]), term, } .upcast(tcx), @@ -664,14 +656,14 @@ where } fn consider_builtin_fused_iterator_candidate( - _ecx: &mut EvalCtxt<'_, Infcx>, + _ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { panic!("`FusedIterator` does not have an associated type: {:?}", goal); } fn consider_builtin_async_iterator_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { let self_ty = goal.predicate.self_ty(); @@ -680,7 +672,7 @@ where }; // Coroutines are not AsyncIterators unless they come from `gen` desugaring - let tcx = ecx.interner(); + let tcx = ecx.cx(); if !tcx.coroutine_is_async_gen(def_id) { return Err(NoSolution); } @@ -707,7 +699,7 @@ where } fn consider_builtin_coroutine_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { let self_ty = goal.predicate.self_ty(); @@ -716,7 +708,7 @@ where }; // `async`-desugared coroutines do not implement the coroutine trait - let tcx = ecx.interner(); + let tcx = ecx.cx(); if !tcx.is_general_coroutine(def_id) { return Err(NoSolution); } @@ -739,7 +731,7 @@ where goal, ty::ProjectionPredicate { projection_term: ty::AliasTerm::new( - ecx.interner(), + ecx.cx(), goal.predicate.def_id(), [self_ty, coroutine.resume_ty()], ), @@ -753,14 +745,14 @@ where } fn consider_structural_builtin_unsize_candidates( - _ecx: &mut EvalCtxt<'_, Infcx>, + _ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Vec> { panic!("`Unsize` does not have an associated type: {:?}", goal); } fn consider_builtin_discriminant_kind_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { let self_ty = goal.predicate.self_ty(); @@ -788,7 +780,7 @@ where | ty::Slice(_) | ty::Dynamic(_, _, _) | ty::Tuple(_) - | ty::Error(_) => self_ty.discriminant_ty(ecx.interner()), + | ty::Error(_) => self_ty.discriminant_ty(ecx.cx()), // We do not call `Ty::discriminant_ty` on alias, param, or placeholder // types, which return `::Discriminant` @@ -812,7 +804,7 @@ where } fn consider_builtin_async_destruct_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { let self_ty = goal.predicate.self_ty(); @@ -835,7 +827,7 @@ where | ty::Str | ty::Slice(_) | ty::Tuple(_) - | ty::Error(_) => self_ty.async_destructor_ty(ecx.interner()), + | ty::Error(_) => self_ty.async_destructor_ty(ecx.cx()), // We do not call `Ty::async_destructor_ty` on alias, param, or placeholder // types, which return `::AsyncDestructor` @@ -865,23 +857,23 @@ where } fn consider_builtin_destruct_candidate( - _ecx: &mut EvalCtxt<'_, Infcx>, + _ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { panic!("`Destruct` does not have an associated type: {:?}", goal); } fn consider_builtin_transmute_candidate( - _ecx: &mut EvalCtxt<'_, Infcx>, + _ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { panic!("`BikeshedIntrinsicFrom` does not have an associated type: {:?}", goal) } } -impl EvalCtxt<'_, Infcx> +impl EvalCtxt<'_, D> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { fn translate_args( @@ -892,7 +884,7 @@ where impl_trait_ref: rustc_type_ir::TraitRef, target_container_def_id: I::DefId, ) -> Result { - let tcx = self.interner(); + let tcx = self.cx(); Ok(if target_container_def_id == impl_trait_ref.def_id { // Default value from the trait definition. No need to rebase. goal.predicate.alias.args diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/opaque_types.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/opaque_types.rs index 710671b45d0e7..f3494328d9e48 100644 --- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/opaque_types.rs +++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/opaque_types.rs @@ -6,19 +6,19 @@ use rustc_index::bit_set::GrowableBitSet; use rustc_type_ir::inherent::*; use rustc_type_ir::{self as ty, Interner}; -use crate::infcx::SolverDelegate; +use crate::delegate::SolverDelegate; use crate::solve::{Certainty, EvalCtxt, Goal, NoSolution, QueryResult, Reveal, SolverMode}; -impl EvalCtxt<'_, Infcx> +impl EvalCtxt<'_, D> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { pub(super) fn normalize_opaque_type( &mut self, goal: Goal>, ) -> QueryResult { - let tcx = self.interner(); + let tcx = self.cx(); let opaque_ty = goal.predicate.alias; let expected = goal.predicate.term.as_type().expect("no such thing as an opaque const"); @@ -34,7 +34,7 @@ where return Err(NoSolution); } // FIXME: This may have issues when the args contain aliases... - match uses_unique_placeholders_ignoring_regions(self.interner(), opaque_ty.args) { + match uses_unique_placeholders_ignoring_regions(self.cx(), opaque_ty.args) { Err(NotUniqueParam::NotParam(param)) if param.is_non_region_infer() => { return self.evaluate_added_goals_and_make_canonical_response( Certainty::AMBIGUOUS, diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/weak_types.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/weak_types.rs index 45341917bb24b..27d5ae07729a6 100644 --- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/weak_types.rs +++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/weak_types.rs @@ -6,19 +6,19 @@ use rustc_type_ir::{self as ty, Interner}; -use crate::infcx::SolverDelegate; +use crate::delegate::SolverDelegate; use crate::solve::{Certainty, EvalCtxt, Goal, GoalSource, QueryResult}; -impl EvalCtxt<'_, Infcx> +impl EvalCtxt<'_, D> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { pub(super) fn normalize_weak_type( &mut self, goal: Goal>, ) -> QueryResult { - let tcx = self.interner(); + let tcx = self.cx(); let weak_ty = goal.predicate.alias; // Check where clauses diff --git a/compiler/rustc_next_trait_solver/src/solve/project_goals.rs b/compiler/rustc_next_trait_solver/src/solve/project_goals.rs index 4bb1fe5be6f01..a430dbb408c5c 100644 --- a/compiler/rustc_next_trait_solver/src/solve/project_goals.rs +++ b/compiler/rustc_next_trait_solver/src/solve/project_goals.rs @@ -1,12 +1,12 @@ use rustc_type_ir::{self as ty, Interner, ProjectionPredicate}; use tracing::instrument; -use crate::infcx::SolverDelegate; +use crate::delegate::SolverDelegate; use crate::solve::{Certainty, EvalCtxt, Goal, GoalSource, QueryResult}; -impl EvalCtxt<'_, Infcx> +impl EvalCtxt<'_, D> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { #[instrument(level = "trace", skip(self), ret)] @@ -14,7 +14,7 @@ where &mut self, goal: Goal>, ) -> QueryResult { - let tcx = self.interner(); + let tcx = self.cx(); let projection_term = goal.predicate.projection_term.to_term(tcx); let goal = goal.with( tcx, diff --git a/compiler/rustc_next_trait_solver/src/solve/search_graph.rs b/compiler/rustc_next_trait_solver/src/solve/search_graph.rs index fc78a864f81a7..d3ad55d6491b0 100644 --- a/compiler/rustc_next_trait_solver/src/solve/search_graph.rs +++ b/compiler/rustc_next_trait_solver/src/solve/search_graph.rs @@ -6,7 +6,7 @@ use rustc_type_ir::inherent::*; use rustc_type_ir::Interner; use tracing::debug; -use crate::infcx::SolverDelegate; +use crate::delegate::SolverDelegate; use crate::solve::inspect::{self, ProofTreeBuilder}; use crate::solve::{ CacheData, CanonicalInput, Certainty, QueryResult, SolverMode, FIXPOINT_STEP_LIMIT, @@ -255,12 +255,12 @@ impl SearchGraph { /// /// Given some goal which is proven via the `prove_goal` closure, this /// handles caching, overflow, and coinductive cycles. - pub(super) fn with_new_goal>( + pub(super) fn with_new_goal>( &mut self, tcx: I, input: CanonicalInput, - inspect: &mut ProofTreeBuilder, - mut prove_goal: impl FnMut(&mut Self, &mut ProofTreeBuilder) -> QueryResult, + inspect: &mut ProofTreeBuilder, + mut prove_goal: impl FnMut(&mut Self, &mut ProofTreeBuilder) -> QueryResult, ) -> QueryResult { self.check_invariants(); // Check for overflow. @@ -416,12 +416,12 @@ impl SearchGraph { /// Try to fetch a previously computed result from the global cache, /// making sure to only do so if it would match the result of reevaluating /// this goal. - fn lookup_global_cache>( + fn lookup_global_cache>( &mut self, tcx: I, input: CanonicalInput, available_depth: SolverLimit, - inspect: &mut ProofTreeBuilder, + inspect: &mut ProofTreeBuilder, ) -> Option> { let CacheData { result, proof_tree, additional_depth, encountered_overflow } = self .global_cache(tcx) @@ -465,16 +465,16 @@ impl SearchGraph { /// of this we continuously recompute the cycle until the result /// of the previous iteration is equal to the final result, at which /// point we are done. - fn fixpoint_step_in_task( + fn fixpoint_step_in_task( &mut self, tcx: I, input: CanonicalInput, - inspect: &mut ProofTreeBuilder, + inspect: &mut ProofTreeBuilder, prove_goal: &mut F, ) -> StepResult where - Infcx: SolverDelegate, - F: FnMut(&mut Self, &mut ProofTreeBuilder) -> QueryResult, + D: SolverDelegate, + F: FnMut(&mut Self, &mut ProofTreeBuilder) -> QueryResult, { let result = prove_goal(self, inspect); let stack_entry = self.pop_stack(); diff --git a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs index c0353f92bf8ac..2ddb3c981db94 100644 --- a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs +++ b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs @@ -8,7 +8,7 @@ use rustc_type_ir::visit::TypeVisitableExt as _; use rustc_type_ir::{self as ty, Interner, TraitPredicate, Upcast as _}; use tracing::{instrument, trace}; -use crate::infcx::SolverDelegate; +use crate::delegate::SolverDelegate; use crate::solve::assembly::structural_traits::{self, AsyncCallableRelevantTypes}; use crate::solve::assembly::{self, Candidate}; use crate::solve::inspect::ProbeKind; @@ -17,9 +17,9 @@ use crate::solve::{ NoSolution, QueryResult, Reveal, SolverMode, }; -impl assembly::GoalKind for TraitPredicate +impl assembly::GoalKind for TraitPredicate where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { fn self_ty(self) -> I::Ty { @@ -39,11 +39,11 @@ where } fn consider_impl_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal>, impl_def_id: I::DefId, ) -> Result, NoSolution> { - let tcx = ecx.interner(); + let tcx = ecx.cx(); let impl_trait_ref = tcx.impl_trait_ref(impl_def_id); if !tcx @@ -91,7 +91,7 @@ where } fn consider_error_guaranteed_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, _guar: I::ErrorGuaranteed, ) -> Result, NoSolution> { // FIXME: don't need to enter a probe here. @@ -100,11 +100,11 @@ where } fn probe_and_match_goal_against_assumption( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, source: CandidateSource, goal: Goal, assumption: I::Clause, - then: impl FnOnce(&mut EvalCtxt<'_, Infcx>) -> QueryResult, + then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult, ) -> Result, NoSolution> { if let Some(trait_clause) = assumption.as_trait_clause() { if trait_clause.def_id() == goal.predicate.def_id() @@ -128,7 +128,7 @@ where } fn consider_auto_trait_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { if goal.predicate.polarity != ty::PredicatePolarity::Positive { @@ -174,14 +174,14 @@ where } fn consider_trait_alias_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { if goal.predicate.polarity != ty::PredicatePolarity::Positive { return Err(NoSolution); } - let tcx = ecx.interner(); + let tcx = ecx.cx(); ecx.probe_builtin_trait_candidate(BuiltinImplSource::Misc).enter(|ecx| { let nested_obligations = tcx @@ -195,7 +195,7 @@ where } fn consider_builtin_sized_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { if goal.predicate.polarity != ty::PredicatePolarity::Positive { @@ -210,7 +210,7 @@ where } fn consider_builtin_copy_clone_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { if goal.predicate.polarity != ty::PredicatePolarity::Positive { @@ -225,14 +225,14 @@ where } fn consider_builtin_pointer_like_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { if goal.predicate.polarity != ty::PredicatePolarity::Positive { return Err(NoSolution); } - let tcx = ecx.interner(); + let tcx = ecx.cx(); // But if there are inference variables, we have to wait until it's resolved. if (goal.param_env, goal.predicate.self_ty()).has_non_region_infer() { return ecx.forced_ambiguity(MaybeCause::Ambiguity); @@ -247,7 +247,7 @@ where } fn consider_builtin_fn_ptr_trait_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { let self_ty = goal.predicate.self_ty(); @@ -278,7 +278,7 @@ where } fn consider_builtin_fn_trait_candidates( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, goal_kind: ty::ClosureKind, ) -> Result, NoSolution> { @@ -286,7 +286,7 @@ where return Err(NoSolution); } - let tcx = ecx.interner(); + let tcx = ecx.cx(); let tupled_inputs_and_output = match structural_traits::extract_tupled_inputs_and_output_from_callable( tcx, @@ -319,7 +319,7 @@ where } fn consider_builtin_async_fn_trait_candidates( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, goal_kind: ty::ClosureKind, ) -> Result, NoSolution> { @@ -327,7 +327,7 @@ where return Err(NoSolution); } - let tcx = ecx.interner(); + let tcx = ecx.cx(); let (tupled_inputs_and_output_and_coroutine, nested_preds) = structural_traits::extract_tupled_inputs_and_output_from_async_callable( tcx, @@ -370,7 +370,7 @@ where } fn consider_builtin_async_fn_kind_helper_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { let [closure_fn_kind_ty, goal_kind_ty] = **goal.predicate.trait_ref.args else { @@ -397,7 +397,7 @@ where /// impl Tuple for (T1, .., Tn) {} /// ``` fn consider_builtin_tuple_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { if goal.predicate.polarity != ty::PredicatePolarity::Positive { @@ -413,7 +413,7 @@ where } fn consider_builtin_pointee_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { if goal.predicate.polarity != ty::PredicatePolarity::Positive { @@ -425,7 +425,7 @@ where } fn consider_builtin_future_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { if goal.predicate.polarity != ty::PredicatePolarity::Positive { @@ -437,7 +437,7 @@ where }; // Coroutines are not futures unless they come from `async` desugaring - let tcx = ecx.interner(); + let tcx = ecx.cx(); if !tcx.coroutine_is_async(def_id) { return Err(NoSolution); } @@ -451,7 +451,7 @@ where } fn consider_builtin_iterator_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { if goal.predicate.polarity != ty::PredicatePolarity::Positive { @@ -463,7 +463,7 @@ where }; // Coroutines are not iterators unless they come from `gen` desugaring - let tcx = ecx.interner(); + let tcx = ecx.cx(); if !tcx.coroutine_is_gen(def_id) { return Err(NoSolution); } @@ -477,7 +477,7 @@ where } fn consider_builtin_fused_iterator_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { if goal.predicate.polarity != ty::PredicatePolarity::Positive { @@ -489,7 +489,7 @@ where }; // Coroutines are not iterators unless they come from `gen` desugaring - let tcx = ecx.interner(); + let tcx = ecx.cx(); if !tcx.coroutine_is_gen(def_id) { return Err(NoSolution); } @@ -501,7 +501,7 @@ where } fn consider_builtin_async_iterator_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { if goal.predicate.polarity != ty::PredicatePolarity::Positive { @@ -513,7 +513,7 @@ where }; // Coroutines are not iterators unless they come from `gen` desugaring - let tcx = ecx.interner(); + let tcx = ecx.cx(); if !tcx.coroutine_is_async_gen(def_id) { return Err(NoSolution); } @@ -527,7 +527,7 @@ where } fn consider_builtin_coroutine_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { if goal.predicate.polarity != ty::PredicatePolarity::Positive { @@ -540,7 +540,7 @@ where }; // `async`-desugared coroutines do not implement the coroutine trait - let tcx = ecx.interner(); + let tcx = ecx.cx(); if !tcx.is_general_coroutine(def_id) { return Err(NoSolution); } @@ -559,7 +559,7 @@ where } fn consider_builtin_discriminant_kind_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { if goal.predicate.polarity != ty::PredicatePolarity::Positive { @@ -572,7 +572,7 @@ where } fn consider_builtin_async_destruct_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { if goal.predicate.polarity != ty::PredicatePolarity::Positive { @@ -585,7 +585,7 @@ where } fn consider_builtin_destruct_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { if goal.predicate.polarity != ty::PredicatePolarity::Positive { @@ -601,7 +601,7 @@ where } fn consider_builtin_transmute_candidate( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Result, NoSolution> { if goal.predicate.polarity != ty::PredicatePolarity::Positive { @@ -634,7 +634,7 @@ where /// impl<'a, T: Trait + 'a> Unsize for T {} /// ``` fn consider_structural_builtin_unsize_candidates( - ecx: &mut EvalCtxt<'_, Infcx>, + ecx: &mut EvalCtxt<'_, D>, goal: Goal, ) -> Vec> { if goal.predicate.polarity != ty::PredicatePolarity::Positive { @@ -657,7 +657,7 @@ where return vec![]; }; - let goal = goal.with(ecx.interner(), (a_ty, b_ty)); + let goal = goal.with(ecx.cx(), (a_ty, b_ty)); match (a_ty.kind(), b_ty.kind()) { (ty::Infer(ty::TyVar(..)), ..) => panic!("unexpected infer {a_ty:?} {b_ty:?}"), @@ -705,9 +705,9 @@ where } } -impl EvalCtxt<'_, Infcx> +impl EvalCtxt<'_, D> where - Infcx: SolverDelegate, + D: SolverDelegate, I: Interner, { /// Trait upcasting allows for coercions between trait objects: @@ -727,7 +727,7 @@ where b_data: I::BoundExistentialPredicates, b_region: I::Region, ) -> Vec> { - let tcx = self.interner(); + let tcx = self.cx(); let Goal { predicate: (a_ty, _b_ty), .. } = goal; let mut responses = vec![]; @@ -745,8 +745,7 @@ where )); } else if let Some(a_principal) = a_data.principal() { for new_a_principal in - Infcx::elaborate_supertraits(self.interner(), a_principal.with_self_ty(tcx, a_ty)) - .skip(1) + D::elaborate_supertraits(self.cx(), a_principal.with_self_ty(tcx, a_ty)).skip(1) { responses.extend(self.consider_builtin_upcast_to_principal( goal, @@ -771,7 +770,7 @@ where b_data: I::BoundExistentialPredicates, b_region: I::Region, ) -> Result, NoSolution> { - let tcx = self.interner(); + let tcx = self.cx(); let Goal { predicate: (a_ty, _), .. } = goal; // Can only unsize to an object-safe trait. @@ -825,10 +824,10 @@ where .auto_traits() .into_iter() .chain(a_data.principal_def_id().into_iter().flat_map(|principal_def_id| { - self.interner() + self.cx() .supertrait_def_ids(principal_def_id) .into_iter() - .filter(|def_id| self.interner().trait_is_auto(*def_id)) + .filter(|def_id| self.cx().trait_is_auto(*def_id)) })) .collect(); @@ -837,7 +836,7 @@ where // having any inference side-effects. We process obligations because // unification may initially succeed due to deferred projection equality. let projection_may_match = - |ecx: &mut EvalCtxt<'_, Infcx>, + |ecx: &mut EvalCtxt<'_, D>, source_projection: ty::Binder>, target_projection: ty::Binder>| { source_projection.item_def_id() == target_projection.item_def_id() @@ -896,7 +895,7 @@ where // Also require that a_ty's lifetime outlives b_ty's lifetime. ecx.add_goal( GoalSource::ImplWhereBound, - Goal::new(ecx.interner(), param_env, ty::OutlivesPredicate(a_region, b_region)), + Goal::new(ecx.cx(), param_env, ty::OutlivesPredicate(a_region, b_region)), ); ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes) @@ -942,7 +941,7 @@ where a_args: I::GenericArgs, b_args: I::GenericArgs, ) -> Result, NoSolution> { - let tcx = self.interner(); + let tcx = self.cx(); let Goal { predicate: (_a_ty, b_ty), .. } = goal; let unsizing_params = tcx.unsizing_params_for_adt(def.def_id()); @@ -1002,7 +1001,7 @@ where a_tys: I::Tys, b_tys: I::Tys, ) -> Result, NoSolution> { - let tcx = self.interner(); + let tcx = self.cx(); let Goal { predicate: (_a_ty, b_ty), .. } = goal; let (&a_last_ty, a_rest_tys) = a_tys.split_last().unwrap(); @@ -1062,11 +1061,9 @@ where // takes precedence over the structural auto trait candidate being // assembled. ty::Coroutine(def_id, _) - if self - .interner() - .is_lang_item(goal.predicate.def_id(), TraitSolverLangItem::Unpin) => + if self.cx().is_lang_item(goal.predicate.def_id(), TraitSolverLangItem::Unpin) => { - match self.interner().coroutine_movability(def_id) { + match self.cx().coroutine_movability(def_id) { Movability::Static => Some(Err(NoSolution)), Movability::Movable => Some( self.probe_builtin_trait_candidate(BuiltinImplSource::Misc).enter(|ecx| { @@ -1111,7 +1108,7 @@ where | ty::Tuple(_) | ty::Adt(_, _) => { let mut disqualifying_impl = None; - self.interner().for_each_relevant_impl( + self.cx().for_each_relevant_impl( goal.predicate.def_id(), goal.predicate.self_ty(), |impl_def_id| { @@ -1140,7 +1137,7 @@ where source: CandidateSource, goal: Goal>, constituent_tys: impl Fn( - &EvalCtxt<'_, Infcx>, + &EvalCtxt<'_, D>, I::Ty, ) -> Result>, NoSolution>, ) -> Result, NoSolution> { @@ -1151,10 +1148,7 @@ where .into_iter() .map(|ty| { ecx.enter_forall(ty, |ty| { - goal.with( - ecx.interner(), - goal.predicate.with_self_ty(ecx.interner(), ty), - ) + goal.with(ecx.cx(), goal.predicate.with_self_ty(ecx.cx(), ty)) }) }) .collect::>(), diff --git a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs index e74c1208a395f..44b31f2659c15 100644 --- a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs +++ b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs @@ -214,7 +214,7 @@ impl<'tcx> TypeFolder> for TransformTy<'tcx> { } } - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } } diff --git a/compiler/rustc_trait_selection/src/solve.rs b/compiler/rustc_trait_selection/src/solve.rs index a7c8cc5a32b60..e47f5389cd180 100644 --- a/compiler/rustc_trait_selection/src/solve.rs +++ b/compiler/rustc_trait_selection/src/solve.rs @@ -1,7 +1,7 @@ pub use rustc_next_trait_solver::solve::*; +mod delegate; mod fulfill; -mod infcx; pub mod inspect; mod normalize; mod select; diff --git a/compiler/rustc_trait_selection/src/solve/infcx.rs b/compiler/rustc_trait_selection/src/solve/delegate.rs similarity index 99% rename from compiler/rustc_trait_selection/src/solve/infcx.rs rename to compiler/rustc_trait_selection/src/solve/delegate.rs index e574166cbfc26..643d5f804808a 100644 --- a/compiler/rustc_trait_selection/src/solve/infcx.rs +++ b/compiler/rustc_trait_selection/src/solve/delegate.rs @@ -39,10 +39,10 @@ impl<'tcx> Deref for SolverDelegate<'tcx> { } } -impl<'tcx> rustc_next_trait_solver::infcx::SolverDelegate for SolverDelegate<'tcx> { +impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<'tcx> { type Interner = TyCtxt<'tcx>; - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.0.tcx } diff --git a/compiler/rustc_trait_selection/src/solve/fulfill.rs b/compiler/rustc_trait_selection/src/solve/fulfill.rs index 8937ed467a1fd..76b88aeb0f7e6 100644 --- a/compiler/rustc_trait_selection/src/solve/fulfill.rs +++ b/compiler/rustc_trait_selection/src/solve/fulfill.rs @@ -17,7 +17,7 @@ use rustc_span::symbol::sym; use crate::traits::{FulfillmentError, FulfillmentErrorCode, ScrubbedTraitError}; -use super::infcx::SolverDelegate; +use super::delegate::SolverDelegate; use super::inspect::{self, ProofTreeInferCtxtExt, ProofTreeVisitor}; use super::Certainty; diff --git a/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs b/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs index cb621487125f7..e8de8457440ff 100644 --- a/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs +++ b/compiler/rustc_trait_selection/src/solve/inspect/analyse.rs @@ -22,7 +22,7 @@ use rustc_next_trait_solver::solve::inspect::{self, instantiate_canonical_state} use rustc_next_trait_solver::solve::{GenerateProofTree, MaybeCause, SolverDelegateEvalExt as _}; use rustc_span::{Span, DUMMY_SP}; -use crate::solve::infcx::SolverDelegate; +use crate::solve::delegate::SolverDelegate; use crate::traits::ObligationCtxt; pub struct InspectConfig { diff --git a/compiler/rustc_trait_selection/src/solve/normalize.rs b/compiler/rustc_trait_selection/src/solve/normalize.rs index f42edebfcc42e..2679da942b763 100644 --- a/compiler/rustc_trait_selection/src/solve/normalize.rs +++ b/compiler/rustc_trait_selection/src/solve/normalize.rs @@ -156,7 +156,7 @@ where { type Error = Vec; - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.at.infcx.tcx } @@ -244,7 +244,7 @@ struct DeeplyNormalizeForDiagnosticsFolder<'a, 'tcx> { } impl<'tcx> TypeFolder> for DeeplyNormalizeForDiagnosticsFolder<'_, 'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.at.infcx.tcx } diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs index 33074c20f575d..b2fa3489dda2b 100644 --- a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs +++ b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs @@ -4936,7 +4936,7 @@ impl<'tcx> TypeFolder> for ReplaceImplTraitFolder<'tcx> { t.super_fold_with(self) } - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.tcx } } diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs index b5f2d34852fc1..d3096cf4b52ce 100644 --- a/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs +++ b/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs @@ -2840,7 +2840,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> { } impl<'a, 'tcx> TypeFolder> for ParamToVarFolder<'a, 'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.infcx.tcx } diff --git a/compiler/rustc_trait_selection/src/traits/mod.rs b/compiler/rustc_trait_selection/src/traits/mod.rs index af6bfdae44029..662d95db8ba5c 100644 --- a/compiler/rustc_trait_selection/src/traits/mod.rs +++ b/compiler/rustc_trait_selection/src/traits/mod.rs @@ -350,7 +350,7 @@ pub fn normalize_param_env_or_error<'tcx>( struct ConstNormalizer<'tcx>(TyCtxt<'tcx>); impl<'tcx> TypeFolder> for ConstNormalizer<'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.0 } diff --git a/compiler/rustc_trait_selection/src/traits/normalize.rs b/compiler/rustc_trait_selection/src/traits/normalize.rs index d7408eab84a45..a9ac0f7eb25bb 100644 --- a/compiler/rustc_trait_selection/src/traits/normalize.rs +++ b/compiler/rustc_trait_selection/src/traits/normalize.rs @@ -163,7 +163,7 @@ impl<'a, 'b, 'tcx> AssocTypeNormalizer<'a, 'b, 'tcx> { } impl<'a, 'b, 'tcx> TypeFolder> for AssocTypeNormalizer<'a, 'b, 'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.selcx.tcx() } @@ -217,7 +217,7 @@ impl<'a, 'b, 'tcx> TypeFolder> for AssocTypeNormalizer<'a, 'b, 'tcx Reveal::UserFacing => ty.super_fold_with(self), Reveal::All => { - let recursion_limit = self.interner().recursion_limit(); + let recursion_limit = self.cx().recursion_limit(); if !recursion_limit.value_within_limit(self.depth) { self.selcx.infcx.err_ctxt().report_overflow_error( OverflowCause::DeeplyNormalize(data.into()), @@ -228,8 +228,8 @@ impl<'a, 'b, 'tcx> TypeFolder> for AssocTypeNormalizer<'a, 'b, 'tcx } let args = data.args.fold_with(self); - let generic_ty = self.interner().type_of(data.def_id); - let concrete_ty = generic_ty.instantiate(self.interner(), args); + let generic_ty = self.cx().type_of(data.def_id); + let concrete_ty = generic_ty.instantiate(self.cx(), args); self.depth += 1; let folded_ty = self.fold_ty(concrete_ty); self.depth -= 1; @@ -313,7 +313,7 @@ impl<'a, 'b, 'tcx> TypeFolder> for AssocTypeNormalizer<'a, 'b, 'tcx normalized_ty } ty::Weak => { - let recursion_limit = self.interner().recursion_limit(); + let recursion_limit = self.cx().recursion_limit(); if !recursion_limit.value_within_limit(self.depth) { self.selcx.infcx.err_ctxt().report_overflow_error( OverflowCause::DeeplyNormalize(data.into()), diff --git a/compiler/rustc_trait_selection/src/traits/query/normalize.rs b/compiler/rustc_trait_selection/src/traits/query/normalize.rs index e170d7cae9379..bed76b84ee075 100644 --- a/compiler/rustc_trait_selection/src/traits/query/normalize.rs +++ b/compiler/rustc_trait_selection/src/traits/query/normalize.rs @@ -172,7 +172,7 @@ struct QueryNormalizer<'cx, 'tcx> { impl<'cx, 'tcx> FallibleTypeFolder> for QueryNormalizer<'cx, 'tcx> { type Error = NoSolution; - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.infcx.tcx } @@ -217,7 +217,7 @@ impl<'cx, 'tcx> FallibleTypeFolder> for QueryNormalizer<'cx, 'tcx> Reveal::All => { let args = data.args.try_fold_with(self)?; - let recursion_limit = self.interner().recursion_limit(); + let recursion_limit = self.cx().recursion_limit(); if !recursion_limit.value_within_limit(self.anon_depth) { let guar = self @@ -229,15 +229,15 @@ impl<'cx, 'tcx> FallibleTypeFolder> for QueryNormalizer<'cx, 'tcx> true, ) .delay_as_bug(); - return Ok(Ty::new_error(self.interner(), guar)); + return Ok(Ty::new_error(self.cx(), guar)); } - let generic_ty = self.interner().type_of(data.def_id); - let mut concrete_ty = generic_ty.instantiate(self.interner(), args); + let generic_ty = self.cx().type_of(data.def_id); + let mut concrete_ty = generic_ty.instantiate(self.cx(), args); self.anon_depth += 1; if concrete_ty == ty { concrete_ty = Ty::new_error_with_message( - self.interner(), + self.cx(), DUMMY_SP, "recursive opaque type", ); diff --git a/compiler/rustc_trait_selection/src/traits/util.rs b/compiler/rustc_trait_selection/src/traits/util.rs index c3fe816028e33..f132e36468ac2 100644 --- a/compiler/rustc_trait_selection/src/traits/util.rs +++ b/compiler/rustc_trait_selection/src/traits/util.rs @@ -394,7 +394,7 @@ impl<'me, 'tcx> BoundVarReplacer<'me, 'tcx> { } impl<'tcx> TypeFolder> for BoundVarReplacer<'_, 'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.infcx.tcx } @@ -509,7 +509,7 @@ impl<'me, 'tcx> PlaceholderReplacer<'me, 'tcx> { } impl<'tcx> TypeFolder> for PlaceholderReplacer<'_, 'tcx> { - fn interner(&self) -> TyCtxt<'tcx> { + fn cx(&self) -> TyCtxt<'tcx> { self.infcx.tcx } @@ -550,7 +550,7 @@ impl<'tcx> TypeFolder> for PlaceholderReplacer<'_, 'tcx> { let db = ty::DebruijnIndex::from_usize( self.universe_indices.len() - index + self.current_index.as_usize() - 1, ); - ty::Region::new_bound(self.interner(), db, *replace_var) + ty::Region::new_bound(self.cx(), db, *replace_var) } None => r1, } diff --git a/compiler/rustc_type_ir/src/binder.rs b/compiler/rustc_type_ir/src/binder.rs index 59de7c552af3c..18b34f8d99b94 100644 --- a/compiler/rustc_type_ir/src/binder.rs +++ b/compiler/rustc_type_ir/src/binder.rs @@ -625,7 +625,7 @@ struct ArgFolder<'a, I: Interner> { impl<'a, I: Interner> TypeFolder for ArgFolder<'a, I> { #[inline] - fn interner(&self) -> I { + fn cx(&self) -> I { self.tcx } @@ -845,7 +845,7 @@ impl<'a, I: Interner> ArgFolder<'a, I> { return val; } - let result = ty::fold::shift_vars(TypeFolder::interner(self), val, self.binders_passed); + let result = ty::fold::shift_vars(TypeFolder::cx(self), val, self.binders_passed); debug!("shift_vars: shifted result = {:?}", result); result diff --git a/compiler/rustc_type_ir/src/fold.rs b/compiler/rustc_type_ir/src/fold.rs index 26e365f64faa3..953a438cb14dc 100644 --- a/compiler/rustc_type_ir/src/fold.rs +++ b/compiler/rustc_type_ir/src/fold.rs @@ -129,7 +129,7 @@ pub trait TypeSuperFoldable: TypeFoldable { /// the infallible methods of this trait to ensure that the two APIs /// are coherent. pub trait TypeFolder: FallibleTypeFolder { - fn interner(&self) -> I; + fn cx(&self) -> I; fn fold_binder(&mut self, t: ty::Binder) -> ty::Binder where @@ -167,7 +167,7 @@ pub trait TypeFolder: FallibleTypeFolder { pub trait FallibleTypeFolder: Sized { type Error; - fn interner(&self) -> I; + fn cx(&self) -> I; fn try_fold_binder(&mut self, t: ty::Binder) -> Result, Self::Error> where @@ -203,8 +203,8 @@ where { type Error = Never; - fn interner(&self) -> I { - TypeFolder::interner(self) + fn cx(&self) -> I { + TypeFolder::cx(self) } fn try_fold_binder(&mut self, t: ty::Binder) -> Result, Never> @@ -351,7 +351,7 @@ impl Shifter { } impl TypeFolder for Shifter { - fn interner(&self) -> I { + fn cx(&self) -> I { self.tcx } diff --git a/compiler/rustc_type_ir/src/ty_kind/closure.rs b/compiler/rustc_type_ir/src/ty_kind/closure.rs index 97752934632c4..3a17a27bd03bb 100644 --- a/compiler/rustc_type_ir/src/ty_kind/closure.rs +++ b/compiler/rustc_type_ir/src/ty_kind/closure.rs @@ -521,7 +521,7 @@ struct FoldEscapingRegions { } impl TypeFolder for FoldEscapingRegions { - fn interner(&self) -> I { + fn cx(&self) -> I { self.interner }