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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> for RemapLateBound<'_, 'tcx> {
- fn interner(&self) -> TyCtxt<'tcx> {
+ fn cx(&self) -> TyCtxt<'tcx> {
self.tcx
}
@@ -790,13 +790,13 @@ impl<'tcx, E> TypeFolder<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>>
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<TyCtxt<'tcx>> for ExternalConstraints<'tcx> {
self,
folder: &mut F,
) -> Result<Self, F::Error> {
- 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<TyCtxt<'tcx>> for ExternalConstraints<'tcx> {
}
fn fold_with<F: TypeFolder<TyCtxt<'tcx>>>(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<TyCtxt<'tcx>> for PredefinedOpaques<'tcx> {
self,
folder: &mut F,
) -> Result<Self, F::Error> {
- Ok(FallibleTypeFolder::interner(folder).mk_predefined_opaques_in_body(
- PredefinedOpaquesData {
- opaque_types: self
- .opaque_types
- .iter()
- .map(|opaque| opaque.try_fold_with(folder))
- .collect::<Result<_, F::Error>>()?,
- },
- ))
+ Ok(FallibleTypeFolder::cx(folder).mk_predefined_opaques_in_body(PredefinedOpaquesData {
+ opaque_types: self
+ .opaque_types
+ .iter()
+ .map(|opaque| opaque.try_fold_with(folder))
+ .collect::<Result<_, F::Error>>()?,
+ }))
}
fn fold_with<F: TypeFolder<TyCtxt<'tcx>>>(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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> for RegionFolder<'a, 'tcx> {
- fn interner(&self) -> TyCtxt<'tcx> {
+ fn cx(&self) -> TyCtxt<'tcx> {
self.tcx
}
@@ -176,7 +176,7 @@ impl<'tcx, D> TypeFolder<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> for &'tcx ty::List<Ty<'tcx>> {
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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> for ReverseMapper<'tcx> {
- fn interner(&self) -> TyCtxt<'tcx> {
+ fn cx(&self) -> TyCtxt<'tcx> {
self.tcx
}
@@ -144,7 +144,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> for Pattern<'tcx> {
folder: &mut F,
) -> Result<Self, F::Error> {
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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> for ty::Predicate<'tcx> {
folder: &mut F,
) -> Result<Self, F::Error> {
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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<Interner = I>, I: Interner> {
- infcx: &'a Infcx,
+pub struct Canonicalizer<'a, D: SolverDelegate<Interner = I>, I: Interner> {
+ delegate: &'a D,
canonicalize_mode: CanonicalizeMode,
variables: &'a mut Vec<I::GenericArg>,
@@ -47,15 +47,15 @@ pub struct Canonicalizer<'a, Infcx: SolverDelegate<Interner = I>, I: Interner> {
binder_index: ty::DebruijnIndex,
}
-impl<'a, Infcx: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, Infcx, I> {
+impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
pub fn canonicalize<T: TypeFoldable<I>>(
- infcx: &'a Infcx,
+ delegate: &'a D,
canonicalize_mode: CanonicalizeMode,
variables: &'a mut Vec<I::GenericArg>,
value: T,
) -> ty::Canonical<I, T> {
let mut canonicalizer = Canonicalizer {
- infcx,
+ delegate,
canonicalize_mode,
variables,
@@ -70,7 +70,7 @@ impl<'a, Infcx: SolverDelegate<Interner = I>, 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<Interner = I>, 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<Interner = I>, 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<Infcx: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I>
- for Canonicalizer<'_, Infcx, I>
-{
- fn interner(&self) -> I {
- self.infcx.interner()
+impl<D: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> for Canonicalizer<'_, D, I> {
+ fn cx(&self) -> I {
+ self.delegate.cx()
}
fn fold_binder<T>(&mut self, t: ty::Binder<I, T>) -> ty::Binder<I, T>
@@ -267,14 +265,14 @@ impl<Infcx: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I>
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<Infcx: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I>
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<Infcx: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I>
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<Infcx: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I>
}
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<Infcx: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I>
}),
);
- 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<Infcx: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I>
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<Infcx: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I>
}),
);
- 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<V>(
- interner: Self::Interner,
+ cx: Self::Interner,
solver_mode: SolverMode,
canonical: &ty::Canonical<Self::Interner, V>,
) -> (Self, V, ty::CanonicalVarValues<Self::Interner>)
@@ -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<Self::Interner, ty::TraitRef<Self::Interner>>,
) -> impl Iterator<Item = ty::Binder<Self::Interner, ty::TraitRef<Self::Interner>>>;
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 = <Infcx as SolverDelegate>::Interner>
+pub struct EagerResolver<'a, D, I = <D as SolverDelegate>::Interner>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
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<Infcx: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> for EagerResolver<'_, Infcx> {
- fn interner(&self) -> I {
- self.infcx.interner()
+impl<D: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> 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<Infcx: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> 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<Infcx: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> 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<Infcx: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> 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<Infcx, I> EvalCtxt<'_, Infcx>
+impl<D, I> EvalCtxt<'_, D>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
I: Interner,
{
#[instrument(level = "trace", skip(self), ret)]
@@ -32,7 +32,7 @@ where
&mut self,
goal: Goal<I, (I::Term, I::Term, ty::AliasRelationDirection)>,
) -> QueryResult<I> {
- 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<I: Interner> {
}
/// Methods used to assemble candidates for either trait or projection goals.
-pub(super) trait GoalKind<Infcx, I = <Infcx as SolverDelegate>::Interner>:
+pub(super) trait GoalKind<D, I = <D as SolverDelegate>::Interner>:
TypeFoldable<I> + Copy + Eq + std::fmt::Display
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
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<I>,
goal: Goal<I, Self>,
assumption: I::Clause,
- then: impl FnOnce(&mut EvalCtxt<'_, Infcx>) -> QueryResult<I>,
+ then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult<I>,
) -> Result<Candidate<I>, 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<I>,
goal: Goal<I, Self>,
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<I>,
goal: Goal<I, Self>,
assumption: I::Clause,
) -> Result<Candidate<I>, 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<I, Self>,
impl_def_id: I::DefId,
) -> Result<Candidate<I>, 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<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
/// A callable type (a closure, fn def, or fn ptr) is known to implement the `Fn<A>`
/// 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<I, Self>,
kind: ty::ClosureKind,
) -> Result<Candidate<I>, NoSolution>;
@@ -173,7 +173,7 @@ where
/// An async closure is known to implement the `AsyncFn<A>` 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<I, Self>,
kind: ty::ClosureKind,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
@@ -206,7 +206,7 @@ where
/// `Future<Output = O>`, 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<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
@@ -214,19 +214,19 @@ where
/// `Iterator<Item = O>`, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
fn consider_builtin_async_iterator_candidate(
- ecx: &mut EvalCtxt<'_, Infcx>,
+ ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
@@ -234,27 +234,27 @@ where
/// implement `Coroutine<R, Yield = Y, Return = O>`, 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<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
fn consider_builtin_discriminant_kind_candidate(
- ecx: &mut EvalCtxt<'_, Infcx>,
+ ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
fn consider_builtin_async_destruct_candidate(
- ecx: &mut EvalCtxt<'_, Infcx>,
+ ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
fn consider_builtin_destruct_candidate(
- ecx: &mut EvalCtxt<'_, Infcx>,
+ ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, NoSolution>;
fn consider_builtin_transmute_candidate(
- ecx: &mut EvalCtxt<'_, Infcx>,
+ ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Vec<Candidate<I>>;
}
-impl<Infcx, I> EvalCtxt<'_, Infcx>
+impl<D, I> EvalCtxt<'_, D>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
I: Interner,
{
- pub(super) fn assemble_and_evaluate_candidates<G: GoalKind<Infcx>>(
+ pub(super) fn assemble_and_evaluate_candidates<G: GoalKind<D>>(
&mut self,
goal: Goal<I, G>,
) -> Vec<Candidate<I>> {
@@ -291,10 +291,8 @@ where
return self.forced_ambiguity(MaybeCause::Ambiguity).into_iter().collect();
}
- let goal: Goal<I, G> = goal.with(
- self.interner(),
- goal.predicate.with_self_ty(self.interner(), normalized_self_ty),
- );
+ let goal: Goal<I, G> =
+ 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<G: GoalKind<Infcx>>(
+ fn assemble_impl_candidates<G: GoalKind<D>>(
&mut self,
goal: Goal<I, G>,
candidates: &mut Vec<Candidate<I>>,
) {
- 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<G: GoalKind<Infcx>>(
+ fn assemble_builtin_impl_candidates<G: GoalKind<D>>(
&mut self,
goal: Goal<I, G>,
candidates: &mut Vec<Candidate<I>>,
) {
- 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<G: GoalKind<Infcx>>(
+ fn assemble_param_env_candidates<G: GoalKind<D>>(
&mut self,
goal: Goal<I, G>,
candidates: &mut Vec<Candidate<I>>,
@@ -453,7 +451,7 @@ where
}
#[instrument(level = "trace", skip_all)]
- fn assemble_alias_bound_candidates<G: GoalKind<Infcx>>(
+ fn assemble_alias_bound_candidates<G: GoalKind<D>>(
&mut self,
goal: Goal<I, G>,
candidates: &mut Vec<Candidate<I>>,
@@ -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<G: GoalKind<Infcx>>(
+ fn assemble_alias_bound_candidates_recur<G: GoalKind<D>>(
&mut self,
self_ty: I::Ty,
goal: Goal<I, G>,
@@ -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<G: GoalKind<Infcx>>(
+ fn assemble_object_bound_candidates<G: GoalKind<D>>(
&mut self,
goal: Goal<I, G>,
candidates: &mut Vec<Candidate<I>>,
) {
- 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<G: GoalKind<Infcx>>(
+ fn assemble_coherence_unknowable_candidates<G: GoalKind<D>>(
&mut self,
goal: Goal<I, G>,
candidates: &mut Vec<Candidate<I>>,
) {
- 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<G: GoalKind<Infcx>>(
+ fn discard_impls_shadowed_by_env<G: GoalKind<D>>(
&mut self,
goal: Goal<I, G>,
candidates: &mut Vec<Candidate<I>>,
) {
- let tcx = self.interner();
+ let tcx = self.cx();
let trait_goal: Goal<I, ty::TraitPredicate<I>> =
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<Infcx, I>(
- ecx: &EvalCtxt<'_, Infcx>,
+pub(in crate::solve) fn instantiate_constituent_tys_for_auto_trait<D, I>(
+ ecx: &EvalCtxt<'_, D>,
ty: I::Ty,
) -> Result<Vec<ty::Binder<I, I::Ty>>, NoSolution>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
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<Infcx, I>(
- ecx: &EvalCtxt<'_, Infcx>,
+pub(in crate::solve) fn instantiate_constituent_tys_for_sized_trait<D, I>(
+ ecx: &EvalCtxt<'_, D>,
ty: I::Ty,
) -> Result<Vec<ty::Binder<I, I::Ty>>, NoSolution>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
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<Infcx, I>(
- ecx: &EvalCtxt<'_, Infcx>,
+pub(in crate::solve) fn instantiate_constituent_tys_for_copy_clone_trait<D, I>(
+ ecx: &EvalCtxt<'_, D>,
ty: I::Ty,
) -> Result<Vec<ty::Binder<I, I::Ty>>, NoSolution>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
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<I: Interner>(
// 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<Infcx, I>(
- ecx: &EvalCtxt<'_, Infcx>,
+pub(in crate::solve) fn predicates_for_object_candidate<D, I>(
+ ecx: &EvalCtxt<'_, D>,
param_env: I::ParamEnv,
trait_ref: ty::TraitRef<I>,
object_bounds: I::BoundExistentialPredicates,
) -> Vec<Goal<I, I::Predicate>>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
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<Interner = I>, I: Interner> {
- ecx: &'a EvalCtxt<'a, Infcx>,
+struct ReplaceProjectionWith<'a, D: SolverDelegate<Interner = I>, I: Interner> {
+ ecx: &'a EvalCtxt<'a, D>,
param_env: I::ParamEnv,
mapping: HashMap<I::DefId, ty::Binder<I, ty::ProjectionPredicate<I>>>,
nested: Vec<Goal<I, I::Predicate>>,
}
-impl<Infcx: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I>
- for ReplaceProjectionWith<'_, Infcx, I>
+impl<D: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I>
+ 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<Infcx: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I>
.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<I: Interner, T> ResponseT<I> for inspect::State<I, T> {
}
}
-impl<Infcx, I> EvalCtxt<'_, Infcx>
+impl<D, I> EvalCtxt<'_, D>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
I: Interner,
{
/// Canonicalizes the goal remembering the original values
@@ -55,19 +55,19 @@ where
&self,
goal: Goal<I, T>,
) -> (Vec<I::GenericArg>, CanonicalInput<I, T>) {
- 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<I> {
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<I>,
) -> (NestedNormalizationGoals<I>, 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<T: ResponseT<I>>(
- infcx: &Infcx,
+ delegate: &D,
original_values: &[I::GenericArg],
response: &Canonical<I, T>,
) -> CanonicalVarValues<I> {
// 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<I>,
@@ -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>, 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, T, I>(
- infcx: &Infcx,
+pub(in crate::solve) fn make_canonical_state<D, T, I>(
+ delegate: &D,
var_values: &[I::GenericArg],
max_input_universe: ty::UniverseIndex,
data: T,
) -> inspect::CanonicalState<I, T>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
I: Interner,
T: TypeFoldable<I>,
{
- 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, I, T: TypeFoldable<I>>(
- infcx: &Infcx,
- span: Infcx::Span,
+pub fn instantiate_canonical_state<D, I, T: TypeFoldable<I>>(
+ delegate: &D,
+ span: D::Span,
param_env: I::ParamEnv,
orig_values: &mut Vec<I::GenericArg>,
state: inspect::CanonicalState<I, T>,
) -> T
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
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 = <Infcx as SolverDelegate>::Interner>
+pub struct EvalCtxt<'a, D, I = <D as SolverDelegate>::Interner>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
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<Infcx>,
+ pub(super) inspect: ProofTreeBuilder<D>,
}
#[derive(derivative::Derivative)]
@@ -143,9 +143,9 @@ pub trait SolverDelegateEvalExt: SolverDelegate {
);
}
-impl<Infcx, I> SolverDelegateEvalExt for Infcx
+impl<D, I> SolverDelegateEvalExt for D
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
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<Interner = I>,
+ D: SolverDelegate<Interner = I>,
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<R>(
- infcx: &Infcx,
+ delegate: &D,
generate_proof_tree: GenerateProofTree,
- f: impl FnOnce(&mut EvalCtxt<'_, Infcx>) -> R,
+ f: impl FnOnce(&mut EvalCtxt<'_, D>) -> R,
) -> (R, Option<inspect::GoalEvaluation<I>>) {
- 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<I>,
canonical_input: CanonicalInput<I>,
- canonical_goal_evaluation: &mut ProofTreeBuilder<Infcx>,
- f: impl FnOnce(&mut EvalCtxt<'_, Infcx>, Goal<I, I::Predicate>) -> R,
+ canonical_goal_evaluation: &mut ProofTreeBuilder<D>,
+ f: impl FnOnce(&mut EvalCtxt<'_, D>, Goal<I, I::Predicate>) -> 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<I>,
canonical_input: CanonicalInput<I>,
- goal_evaluation: &mut ProofTreeBuilder<Infcx>,
+ goal_evaluation: &mut ProofTreeBuilder<D>,
) -> QueryResult<I> {
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<Option<Certainty>, 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<Interner = I>, I: Interner> {
+ struct ContainsTermOrNotNameable<'a, D: SolverDelegate<Interner = I>, I: Interner> {
term: I::Term,
universe_of_term: ty::UniverseIndex,
- infcx: &'a Infcx,
+ delegate: &'a D,
}
- impl<Infcx: SolverDelegate<Interner = I>, I: Interner> ContainsTermOrNotNameable<'_, Infcx, I> {
+ impl<D: SolverDelegate<Interner = I>, 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<Infcx: SolverDelegate<Interner = I>, I: Interner> TypeVisitor<I>
- for ContainsTermOrNotNameable<'_, Infcx, I>
+ impl<D: SolverDelegate<Interner = I>, I: Interner> TypeVisitor<I>
+ 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<Vec<Goal<I, I::Predicate>>, 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<T: TypeFoldable<I> + Copy>(
&self,
value: ty::Binder<I, T>,
) -> T {
- self.infcx.instantiate_binder_with_infer(value)
+ self.delegate.instantiate_binder_with_infer(value)
}
pub(super) fn enter_forall<T: TypeFoldable<I> + Copy, U>(
@@ -861,18 +863,18 @@ where
value: ty::Binder<I, T>,
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<T>(&self, value: T) -> T
where
T: TypeFoldable<I>,
{
- 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<Vec<Goal<I, I::Predicate>>> {
- 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<I>,
) -> Result<bool, NoSolution> {
- 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<Option<I::DefId>, 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<CanonicalResponse<I>> {
// 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<I>,
) -> Option<I::Const> {
- 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<Certainty, NoSolution> {
- 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<Interner = I>,
+ D: SolverDelegate<Interner = I>,
I: Interner,
{
- ecx: &'me mut EvalCtxt<'a, Infcx>,
+ ecx: &'me mut EvalCtxt<'a, D>,
param_env: I::ParamEnv,
}
-impl<Infcx, I> TypeFolder<I> for ReplaceAliasWithInfer<'_, '_, Infcx, I>
+impl<D, I> TypeFolder<I> for ReplaceAliasWithInfer<'_, '_, D, I>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
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<Interner = I>,
+ D: SolverDelegate<Interner = I>,
I: Interner,
{
- ecx: &'me mut EvalCtxt<'a, Infcx, I>,
+ ecx: &'me mut EvalCtxt<'a, D, I>,
probe_kind: F,
_result: PhantomData<T>,
}
-impl<Infcx, I, F, T> ProbeCtxt<'_, '_, Infcx, I, F, T>
+impl<D, I, F, T> ProbeCtxt<'_, '_, D, I, F, T>
where
F: FnOnce(&T) -> inspect::ProbeKind<I>,
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
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<Interner = I>,
+ D: SolverDelegate<Interner = I>,
I: Interner,
{
- cx: ProbeCtxt<'me, 'a, Infcx, I, F, QueryResult<I>>,
+ cx: ProbeCtxt<'me, 'a, D, I, F, QueryResult<I>>,
source: CandidateSource<I>,
}
-impl<Infcx, I, F> TraitProbeCtxt<'_, '_, Infcx, I, F>
+impl<D, I, F> TraitProbeCtxt<'_, '_, D, I, F>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
I: Interner,
F: FnOnce(&QueryResult<I>) -> inspect::ProbeKind<I>,
{
#[instrument(level = "debug", skip_all, fields(source = ?self.source))]
pub(in crate::solve) fn enter(
self,
- f: impl FnOnce(&mut EvalCtxt<'_, Infcx>) -> QueryResult<I>,
+ f: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult<I>,
) -> Result<Candidate<I>, 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<Interner = I>,
+ D: SolverDelegate<Interner = I>,
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<F, T>(
- &mut self,
- probe_kind: F,
- ) -> ProbeCtxt<'_, 'a, Infcx, I, F, T>
+ pub(in crate::solve) fn probe<F, T>(&mut self, probe_kind: F) -> ProbeCtxt<'_, 'a, D, I, F, T>
where
F: FnOnce(&T) -> inspect::ProbeKind<I>,
{
@@ -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<I>) -> inspect::ProbeKind<I>>
- {
+ ) -> TraitProbeCtxt<'_, 'a, D, I, impl FnOnce(&QueryResult<I>) -> inspect::ProbeKind<I>> {
self.probe_trait_candidate(CandidateSource::BuiltinImpl(source))
}
pub(in crate::solve) fn probe_trait_candidate(
&mut self,
source: CandidateSource<I>,
- ) -> TraitProbeCtxt<'_, 'a, Infcx, I, impl FnOnce(&QueryResult<I>) -> inspect::ProbeKind<I>>
- {
+ ) -> TraitProbeCtxt<'_, 'a, D, I, impl FnOnce(&QueryResult<I>) -> inspect::ProbeKind<I>> {
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<Infcx, I = <Infcx as SolverDelegate>::Interner>
+pub(in crate::solve) struct ProofTreeBuilder<D, I = <D as SolverDelegate>::Interner>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
I: Interner,
{
- _infcx: PhantomData<Infcx>,
+ _infcx: PhantomData<D>,
state: Option<Box<DebugSolver<I>>>,
}
@@ -235,8 +235,8 @@ impl<I: Interner> WipProbeStep<I> {
}
}
-impl<Infcx: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<Infcx> {
- fn new(state: impl Into<DebugSolver<I>>) -> ProofTreeBuilder<Infcx> {
+impl<D: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<D> {
+ fn new(state: impl Into<DebugSolver<I>>) -> ProofTreeBuilder<D> {
ProofTreeBuilder { state: Some(Box::new(state.into())), _infcx: PhantomData }
}
@@ -258,7 +258,7 @@ impl<Infcx: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<Infcx> {
self.state.as_deref_mut()
}
- pub fn take_and_enter_probe(&mut self) -> ProofTreeBuilder<Infcx> {
+ pub fn take_and_enter_probe(&mut self) -> ProofTreeBuilder<D> {
let mut nested = ProofTreeBuilder { state: self.state.take(), _infcx: PhantomData };
nested.enter_probe();
nested
@@ -273,18 +273,18 @@ impl<Infcx: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<Infcx> {
}
}
- pub fn new_maybe_root(generate_proof_tree: GenerateProofTree) -> ProofTreeBuilder<Infcx> {
+ pub fn new_maybe_root(generate_proof_tree: GenerateProofTree) -> ProofTreeBuilder<D> {
match generate_proof_tree {
GenerateProofTree::No => ProofTreeBuilder::new_noop(),
GenerateProofTree::Yes => ProofTreeBuilder::new_root(),
}
}
- pub fn new_root() -> ProofTreeBuilder<Infcx> {
+ pub fn new_root() -> ProofTreeBuilder<D> {
ProofTreeBuilder::new(DebugSolver::Root)
}
- pub fn new_noop() -> ProofTreeBuilder<Infcx> {
+ pub fn new_noop() -> ProofTreeBuilder<D> {
ProofTreeBuilder { state: None, _infcx: PhantomData }
}
@@ -297,7 +297,7 @@ impl<Infcx: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<Infcx> {
goal: Goal<I, I::Predicate>,
orig_values: &[I::GenericArg],
kind: GoalEvaluationKind,
- ) -> ProofTreeBuilder<Infcx> {
+ ) -> ProofTreeBuilder<D> {
self.opt_nested(|| match kind {
GoalEvaluationKind::Root => Some(WipGoalEvaluation {
uncanonicalized_goal: goal,
@@ -311,7 +311,7 @@ impl<Infcx: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<Infcx> {
pub fn new_canonical_goal_evaluation(
&mut self,
goal: CanonicalInput<I>,
- ) -> ProofTreeBuilder<Infcx> {
+ ) -> ProofTreeBuilder<D> {
self.nested(|| WipCanonicalGoalEvaluation {
goal,
kind: None,
@@ -337,10 +337,7 @@ impl<Infcx: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<Infcx> {
})
}
- pub fn canonical_goal_evaluation(
- &mut self,
- canonical_goal_evaluation: ProofTreeBuilder<Infcx>,
- ) {
+ pub fn canonical_goal_evaluation(&mut self, canonical_goal_evaluation: ProofTreeBuilder<D>) {
if let Some(this) = self.as_mut() {
match (this, *canonical_goal_evaluation.state.unwrap()) {
(
@@ -366,7 +363,7 @@ impl<Infcx: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<Infcx> {
}
}
- pub fn goal_evaluation(&mut self, goal_evaluation: ProofTreeBuilder<Infcx>) {
+ pub fn goal_evaluation(&mut self, goal_evaluation: ProofTreeBuilder<D>) {
if let Some(this) = self.as_mut() {
match this {
DebugSolver::Root => *this = *goal_evaluation.state.unwrap(),
@@ -382,7 +379,7 @@ impl<Infcx: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<Infcx> {
&mut self,
var_values: ty::CanonicalVarValues<I>,
instantiated_goal: QueryInput<I, I::Predicate>,
- ) -> ProofTreeBuilder<Infcx> {
+ ) -> ProofTreeBuilder<D> {
self.nested(|| WipCanonicalGoalEvaluationStep {
var_values: var_values.var_values.to_vec(),
instantiated_goal,
@@ -396,7 +393,7 @@ impl<Infcx: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<Infcx> {
})
}
- pub fn goal_evaluation_step(&mut self, goal_evaluation_step: ProofTreeBuilder<Infcx>) {
+ pub fn goal_evaluation_step(&mut self, goal_evaluation_step: ProofTreeBuilder<D>) {
if let Some(this) = self.as_mut() {
match (this, *goal_evaluation_step.state.unwrap()) {
(
@@ -448,12 +445,12 @@ impl<Infcx: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<Infcx> {
}
}
- 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<Infcx: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<Infcx> {
pub fn add_normalizes_to_goal(
&mut self,
- infcx: &Infcx,
+ delegate: &D,
max_input_universe: ty::UniverseIndex,
goal: Goal<I, ty::NormalizesTo<I>>,
) {
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<I, I::Predicate>,
@@ -490,7 +487,7 @@ impl<Infcx: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<Infcx> {
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<Infcx: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<Infcx> {
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<Infcx: SolverDelegate<Interner = I>, I: Interner> ProofTreeBuilder<Infcx> {
}
}
- pub fn finish_probe(mut self) -> ProofTreeBuilder<Infcx> {
+ pub fn finish_probe(mut self) -> ProofTreeBuilder<D> {
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<I: Interner>(
&& 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<Interner = I>,
+ D: SolverDelegate<Interner = I>,
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<I> {
- 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<Infcx, I> EvalCtxt<'_, Infcx>
+impl<D, I> EvalCtxt<'_, D>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
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<Infcx, I> EvalCtxt<'_, Infcx>
+impl<D, I> EvalCtxt<'_, D>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
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<Infcx, I> EvalCtxt<'_, Infcx>
+impl<D, I> EvalCtxt<'_, D>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
I: Interner,
{
pub(super) fn normalize_inherent_associated_type(
&mut self,
goal: Goal<I, ty::NormalizesTo<I>>,
) -> QueryResult<I> {
- 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<Infcx, I> EvalCtxt<'_, Infcx>
+impl<D, I> EvalCtxt<'_, D>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
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<I, NormalizesTo<I>>) -> QueryResult<I> {
- 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<Infcx, I> assembly::GoalKind<Infcx> for NormalizesTo<I>
+impl<D, I> assembly::GoalKind<D> for NormalizesTo<I>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
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<I>,
goal: Goal<I, Self>,
assumption: I::Clause,
- then: impl FnOnce(&mut EvalCtxt<'_, Infcx>) -> QueryResult<I>,
+ then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult<I>,
) -> Result<Candidate<I>, 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<I, NormalizesTo<I>>,
impl_def_id: I::DefId,
) -> Result<Candidate<I>, 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<Candidate<I>, NoSolution> {
Err(NoSolution)
}
fn consider_auto_trait_candidate(
- ecx: &mut EvalCtxt<'_, Infcx>,
+ ecx: &mut EvalCtxt<'_, D>,
_goal: Goal<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
goal_kind: ty::ClosureKind,
) -> Result<Candidate<I>, 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<I, Self>,
goal_kind: ty::ClosureKind,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Vec<Candidate<I>> {
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<I, Self>,
) -> Result<Candidate<I>, 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 `<self_ty as DiscriminantKind>::Discriminant`
@@ -812,7 +804,7 @@ where
}
fn consider_builtin_async_destruct_candidate(
- ecx: &mut EvalCtxt<'_, Infcx>,
+ ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, 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 `<self_ty as AsyncDestruct>::AsyncDestructor`
@@ -865,23 +857,23 @@ where
}
fn consider_builtin_destruct_candidate(
- _ecx: &mut EvalCtxt<'_, Infcx>,
+ _ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, NoSolution> {
panic!("`BikeshedIntrinsicFrom` does not have an associated type: {:?}", goal)
}
}
-impl<Infcx, I> EvalCtxt<'_, Infcx>
+impl<D, I> EvalCtxt<'_, D>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
I: Interner,
{
fn translate_args(
@@ -892,7 +884,7 @@ where
impl_trait_ref: rustc_type_ir::TraitRef<I>,
target_container_def_id: I::DefId,
) -> Result<I::GenericArgs, NoSolution> {
- 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<Infcx, I> EvalCtxt<'_, Infcx>
+impl<D, I> EvalCtxt<'_, D>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
I: Interner,
{
pub(super) fn normalize_opaque_type(
&mut self,
goal: Goal<I, ty::NormalizesTo<I>>,
) -> QueryResult<I> {
- 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<Infcx, I> EvalCtxt<'_, Infcx>
+impl<D, I> EvalCtxt<'_, D>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
I: Interner,
{
pub(super) fn normalize_weak_type(
&mut self,
goal: Goal<I, ty::NormalizesTo<I>>,
) -> QueryResult<I> {
- 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<Infcx, I> EvalCtxt<'_, Infcx>
+impl<D, I> EvalCtxt<'_, D>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
I: Interner,
{
#[instrument(level = "trace", skip(self), ret)]
@@ -14,7 +14,7 @@ where
&mut self,
goal: Goal<I, ProjectionPredicate<I>>,
) -> QueryResult<I> {
- 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<I: Interner> SearchGraph<I> {
///
/// Given some goal which is proven via the `prove_goal` closure, this
/// handles caching, overflow, and coinductive cycles.
- pub(super) fn with_new_goal<Infcx: SolverDelegate<Interner = I>>(
+ pub(super) fn with_new_goal<D: SolverDelegate<Interner = I>>(
&mut self,
tcx: I,
input: CanonicalInput<I>,
- inspect: &mut ProofTreeBuilder<Infcx>,
- mut prove_goal: impl FnMut(&mut Self, &mut ProofTreeBuilder<Infcx>) -> QueryResult<I>,
+ inspect: &mut ProofTreeBuilder<D>,
+ mut prove_goal: impl FnMut(&mut Self, &mut ProofTreeBuilder<D>) -> QueryResult<I>,
) -> QueryResult<I> {
self.check_invariants();
// Check for overflow.
@@ -416,12 +416,12 @@ impl<I: Interner> SearchGraph<I> {
/// 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<Infcx: SolverDelegate<Interner = I>>(
+ fn lookup_global_cache<D: SolverDelegate<Interner = I>>(
&mut self,
tcx: I,
input: CanonicalInput<I>,
available_depth: SolverLimit,
- inspect: &mut ProofTreeBuilder<Infcx>,
+ inspect: &mut ProofTreeBuilder<D>,
) -> Option<QueryResult<I>> {
let CacheData { result, proof_tree, additional_depth, encountered_overflow } = self
.global_cache(tcx)
@@ -465,16 +465,16 @@ impl<I: Interner> SearchGraph<I> {
/// 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<Infcx, F>(
+ fn fixpoint_step_in_task<D, F>(
&mut self,
tcx: I,
input: CanonicalInput<I>,
- inspect: &mut ProofTreeBuilder<Infcx>,
+ inspect: &mut ProofTreeBuilder<D>,
prove_goal: &mut F,
) -> StepResult<I>
where
- Infcx: SolverDelegate<Interner = I>,
- F: FnMut(&mut Self, &mut ProofTreeBuilder<Infcx>) -> QueryResult<I>,
+ D: SolverDelegate<Interner = I>,
+ F: FnMut(&mut Self, &mut ProofTreeBuilder<D>) -> QueryResult<I>,
{
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<Infcx, I> assembly::GoalKind<Infcx> for TraitPredicate<I>
+impl<D, I> assembly::GoalKind<D> for TraitPredicate<I>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
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<I, TraitPredicate<I>>,
impl_def_id: I::DefId,
) -> Result<Candidate<I>, 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<Candidate<I>, 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<I>,
goal: Goal<I, Self>,
assumption: I::Clause,
- then: impl FnOnce(&mut EvalCtxt<'_, Infcx>) -> QueryResult<I>,
+ then: impl FnOnce(&mut EvalCtxt<'_, D>) -> QueryResult<I>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
goal_kind: ty::ClosureKind,
) -> Result<Candidate<I>, 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<I, Self>,
goal_kind: ty::ClosureKind,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, 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<I, Self>,
) -> Result<Candidate<I>, NoSolution> {
if goal.predicate.polarity != ty::PredicatePolarity::Positive {
@@ -634,7 +634,7 @@ where
/// impl<'a, T: Trait + 'a> Unsize<dyn Trait + 'a> for T {}
/// ```
fn consider_structural_builtin_unsize_candidates(
- ecx: &mut EvalCtxt<'_, Infcx>,
+ ecx: &mut EvalCtxt<'_, D>,
goal: Goal<I, Self>,
) -> Vec<Candidate<I>> {
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<Infcx, I> EvalCtxt<'_, Infcx>
+impl<D, I> EvalCtxt<'_, D>
where
- Infcx: SolverDelegate<Interner = I>,
+ D: SolverDelegate<Interner = I>,
I: Interner,
{
/// Trait upcasting allows for coercions between trait objects:
@@ -727,7 +727,7 @@ where
b_data: I::BoundExistentialPredicates,
b_region: I::Region,
) -> Vec<Candidate<I>> {
- 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<Candidate<I>, 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<I, ty::ExistentialProjection<I>>,
target_projection: ty::Binder<I, ty::ExistentialProjection<I>>| {
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<Candidate<I>, 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<Candidate<I>, 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<I>,
goal: Goal<I, TraitPredicate<I>>,
constituent_tys: impl Fn(
- &EvalCtxt<'_, Infcx>,
+ &EvalCtxt<'_, D>,
I::Ty,
) -> Result<Vec<ty::Binder<I, I::Ty>>, NoSolution>,
) -> Result<Candidate<I>, 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::<Vec<_>>(),
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<TyCtxt<'tcx>> 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<E>;
- 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> 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<TyCtxt<'tcx>> for PlaceholderReplacer<'_, 'tcx> {
- fn interner(&self) -> TyCtxt<'tcx> {
+ fn cx(&self) -> TyCtxt<'tcx> {
self.infcx.tcx
}
@@ -550,7 +550,7 @@ impl<'tcx> TypeFolder<TyCtxt<'tcx>> 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<I> 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<I: Interner>: TypeFoldable<I> {
/// the infallible methods of this trait to ensure that the two APIs
/// are coherent.
pub trait TypeFolder<I: Interner>: FallibleTypeFolder<I, Error = Never> {
- fn interner(&self) -> I;
+ fn cx(&self) -> I;
fn fold_binder<T>(&mut self, t: ty::Binder<I, T>) -> ty::Binder<I, T>
where
@@ -167,7 +167,7 @@ pub trait TypeFolder<I: Interner>: FallibleTypeFolder<I, Error = Never> {
pub trait FallibleTypeFolder<I: Interner>: Sized {
type Error;
- fn interner(&self) -> I;
+ fn cx(&self) -> I;
fn try_fold_binder<T>(&mut self, t: ty::Binder<I, T>) -> Result<ty::Binder<I, T>, 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<T>(&mut self, t: ty::Binder<I, T>) -> Result<ty::Binder<I, T>, Never>
@@ -351,7 +351,7 @@ impl<I: Interner> Shifter<I> {
}
impl<I: Interner> TypeFolder<I> for Shifter<I> {
- 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<I: Interner> {
}
impl<I: Interner> TypeFolder<I> for FoldEscapingRegions<I> {
- fn interner(&self) -> I {
+ fn cx(&self) -> I {
self.interner
}