diff --git a/Cargo.lock b/Cargo.lock
index 9c0978b92f73c..df2842bddb386 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4618,7 +4618,7 @@ dependencies = [
"derive-where",
"ena",
"indexmap",
- "rustc-hash 1.1.0",
+ "rustc-hash 2.1.1",
"rustc_ast_ir",
"rustc_data_structures",
"rustc_index",
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
index bdc42c7a2d909..106420faa4c01 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/bounds.rs
@@ -9,8 +9,8 @@ use rustc_hir::def::{DefKind, Res};
use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_middle::bug;
use rustc_middle::ty::{
- self as ty, IsSuggestable, Ty, TyCtxt, TypeFoldable, TypeSuperVisitable, TypeVisitable,
- TypeVisitableExt, TypeVisitor, Upcast,
+ self as ty, IsSuggestable, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitableExt,
+ TypeVisitor, Upcast,
};
use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol, kw, sym};
use rustc_trait_selection::traits;
@@ -927,7 +927,7 @@ struct GenericParamAndBoundVarCollector<'a, 'tcx> {
impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for GenericParamAndBoundVarCollector<'_, 'tcx> {
type Result = ControlFlow<ErrorGuaranteed>;
- fn visit_binder<T: TypeFoldable<TyCtxt<'tcx>>>(
+ fn visit_binder<T: TypeVisitable<TyCtxt<'tcx>>>(
&mut self,
binder: &ty::Binder<'tcx, T>,
) -> Self::Result {
diff --git a/compiler/rustc_lint/src/impl_trait_overcaptures.rs b/compiler/rustc_lint/src/impl_trait_overcaptures.rs
index 8124d7f7c86a1..aa6f36a67f09a 100644
--- a/compiler/rustc_lint/src/impl_trait_overcaptures.rs
+++ b/compiler/rustc_lint/src/impl_trait_overcaptures.rs
@@ -15,8 +15,7 @@ use rustc_middle::ty::relate::{
Relate, RelateResult, TypeRelation, structurally_relate_consts, structurally_relate_tys,
};
use rustc_middle::ty::{
- self, Ty, TyCtxt, TypeFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitableExt,
- TypeVisitor,
+ self, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor,
};
use rustc_middle::{bug, span_bug};
use rustc_session::lint::FutureIncompatibilityReason;
@@ -210,7 +209,7 @@ where
VarFn: FnOnce() -> FxHashMap<DefId, ty::Variance>,
OutlivesFn: FnOnce() -> OutlivesEnvironment<'tcx>,
{
- fn visit_binder<T: TypeFoldable<TyCtxt<'tcx>>>(&mut self, t: &ty::Binder<'tcx, T>) {
+ fn visit_binder<T: TypeVisitable<TyCtxt<'tcx>>>(&mut self, t: &ty::Binder<'tcx, T>) {
// When we get into a binder, we need to add its own bound vars to the scope.
let mut added = vec![];
for arg in t.bound_vars() {
diff --git a/compiler/rustc_middle/src/ty/consts.rs b/compiler/rustc_middle/src/ty/consts.rs
index 455ac66041261..2fbaa2221a18b 100644
--- a/compiler/rustc_middle/src/ty/consts.rs
+++ b/compiler/rustc_middle/src/ty/consts.rs
@@ -163,6 +163,10 @@ impl<'tcx> rustc_type_ir::inherent::Const<TyCtxt<'tcx>> for Const<'tcx> {
Const::new_bound(tcx, debruijn, var)
}
+ fn new_placeholder(tcx: TyCtxt<'tcx>, placeholder: ty::PlaceholderConst) -> Self {
+ Const::new_placeholder(tcx, placeholder)
+ }
+
fn new_unevaluated(interner: TyCtxt<'tcx>, uv: ty::UnevaluatedConst<'tcx>) -> Self {
Const::new_unevaluated(interner, uv)
}
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index dc3f2844e5ae8..0402d09882254 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -933,7 +933,9 @@ impl Placeholder<BoundVar> {
pub type PlaceholderRegion = Placeholder<BoundRegion>;
-impl rustc_type_ir::inherent::PlaceholderLike for PlaceholderRegion {
+impl<'tcx> rustc_type_ir::inherent::PlaceholderLike<TyCtxt<'tcx>> for PlaceholderRegion {
+ type Bound = BoundRegion;
+
fn universe(self) -> UniverseIndex {
self.universe
}
@@ -946,14 +948,20 @@ impl rustc_type_ir::inherent::PlaceholderLike for PlaceholderRegion {
Placeholder { universe: ui, ..self }
}
- fn new(ui: UniverseIndex, var: BoundVar) -> Self {
+ fn new(ui: UniverseIndex, bound: BoundRegion) -> Self {
+ Placeholder { universe: ui, bound }
+ }
+
+ fn new_anon(ui: UniverseIndex, var: BoundVar) -> Self {
Placeholder { universe: ui, bound: BoundRegion { var, kind: BoundRegionKind::Anon } }
}
}
pub type PlaceholderType = Placeholder<BoundTy>;
-impl rustc_type_ir::inherent::PlaceholderLike for PlaceholderType {
+impl<'tcx> rustc_type_ir::inherent::PlaceholderLike<TyCtxt<'tcx>> for PlaceholderType {
+ type Bound = BoundTy;
+
fn universe(self) -> UniverseIndex {
self.universe
}
@@ -966,7 +974,11 @@ impl rustc_type_ir::inherent::PlaceholderLike for PlaceholderType {
Placeholder { universe: ui, ..self }
}
- fn new(ui: UniverseIndex, var: BoundVar) -> Self {
+ fn new(ui: UniverseIndex, bound: BoundTy) -> Self {
+ Placeholder { universe: ui, bound }
+ }
+
+ fn new_anon(ui: UniverseIndex, var: BoundVar) -> Self {
Placeholder { universe: ui, bound: BoundTy { var, kind: BoundTyKind::Anon } }
}
}
@@ -980,7 +992,9 @@ pub struct BoundConst<'tcx> {
pub type PlaceholderConst = Placeholder<BoundVar>;
-impl rustc_type_ir::inherent::PlaceholderLike for PlaceholderConst {
+impl<'tcx> rustc_type_ir::inherent::PlaceholderLike<TyCtxt<'tcx>> for PlaceholderConst {
+ type Bound = BoundVar;
+
fn universe(self) -> UniverseIndex {
self.universe
}
@@ -993,7 +1007,11 @@ impl rustc_type_ir::inherent::PlaceholderLike for PlaceholderConst {
Placeholder { universe: ui, ..self }
}
- fn new(ui: UniverseIndex, var: BoundVar) -> Self {
+ fn new(ui: UniverseIndex, bound: BoundVar) -> Self {
+ Placeholder { universe: ui, bound }
+ }
+
+ fn new_anon(ui: UniverseIndex, var: BoundVar) -> Self {
Placeholder { universe: ui, bound: var }
}
}
diff --git a/compiler/rustc_middle/src/ty/region.rs b/compiler/rustc_middle/src/ty/region.rs
index 3e4f7a79d5394..cc25cd16567b1 100644
--- a/compiler/rustc_middle/src/ty/region.rs
+++ b/compiler/rustc_middle/src/ty/region.rs
@@ -148,6 +148,10 @@ impl<'tcx> rustc_type_ir::inherent::Region<TyCtxt<'tcx>> for Region<'tcx> {
Region::new_bound(tcx, debruijn, ty::BoundRegion { var, kind: ty::BoundRegionKind::Anon })
}
+ fn new_placeholder(tcx: TyCtxt<'tcx>, placeholder: ty::PlaceholderRegion) -> Self {
+ Region::new_placeholder(tcx, placeholder)
+ }
+
fn new_static(tcx: TyCtxt<'tcx>) -> Self {
tcx.lifetimes.re_static
}
diff --git a/compiler/rustc_middle/src/ty/visit.rs b/compiler/rustc_middle/src/ty/visit.rs
index f804217459915..3853a804a920f 100644
--- a/compiler/rustc_middle/src/ty/visit.rs
+++ b/compiler/rustc_middle/src/ty/visit.rs
@@ -66,7 +66,7 @@ impl<'tcx> TyCtxt<'tcx> {
{
type Result = ControlFlow<()>;
- fn visit_binder<T: TypeFoldable<TyCtxt<'tcx>>>(
+ fn visit_binder<T: TypeVisitable<TyCtxt<'tcx>>>(
&mut self,
t: &Binder<'tcx, T>,
) -> Self::Result {
@@ -168,7 +168,7 @@ impl LateBoundRegionsCollector {
}
impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for LateBoundRegionsCollector {
- fn visit_binder<T: TypeFoldable<TyCtxt<'tcx>>>(&mut self, t: &Binder<'tcx, T>) {
+ fn visit_binder<T: TypeVisitable<TyCtxt<'tcx>>>(&mut self, t: &Binder<'tcx, T>) {
self.current_index.shift_in(1);
t.super_visit_with(self);
self.current_index.shift_out(1);
diff --git a/compiler/rustc_next_trait_solver/src/canonicalizer.rs b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
index cea7753317863..47ed9e8724482 100644
--- a/compiler/rustc_next_trait_solver/src/canonicalizer.rs
+++ b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
@@ -435,13 +435,13 @@ impl<'a, D: SolverDelegate<Interner = I>, I: Interner> Canonicalizer<'a, D, I> {
},
ty::Placeholder(placeholder) => match self.canonicalize_mode {
CanonicalizeMode::Input { .. } => CanonicalVarKind::PlaceholderTy(
- PlaceholderLike::new(placeholder.universe(), self.variables.len().into()),
+ PlaceholderLike::new_anon(placeholder.universe(), self.variables.len().into()),
),
CanonicalizeMode::Response { .. } => CanonicalVarKind::PlaceholderTy(placeholder),
},
ty::Param(_) => match self.canonicalize_mode {
CanonicalizeMode::Input { .. } => CanonicalVarKind::PlaceholderTy(
- PlaceholderLike::new(ty::UniverseIndex::ROOT, self.variables.len().into()),
+ PlaceholderLike::new_anon(ty::UniverseIndex::ROOT, self.variables.len().into()),
),
CanonicalizeMode::Response { .. } => panic!("param ty in response: {t:?}"),
},
@@ -594,7 +594,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> for Canonicaliz
},
ty::ConstKind::Placeholder(placeholder) => match self.canonicalize_mode {
CanonicalizeMode::Input { .. } => CanonicalVarKind::PlaceholderConst(
- PlaceholderLike::new(placeholder.universe(), self.variables.len().into()),
+ PlaceholderLike::new_anon(placeholder.universe(), self.variables.len().into()),
),
CanonicalizeMode::Response { .. } => {
CanonicalVarKind::PlaceholderConst(placeholder)
@@ -602,7 +602,7 @@ impl<D: SolverDelegate<Interner = I>, I: Interner> TypeFolder<I> for Canonicaliz
},
ty::ConstKind::Param(_) => match self.canonicalize_mode {
CanonicalizeMode::Input { .. } => CanonicalVarKind::PlaceholderConst(
- PlaceholderLike::new(ty::UniverseIndex::ROOT, self.variables.len().into()),
+ PlaceholderLike::new_anon(ty::UniverseIndex::ROOT, self.variables.len().into()),
),
CanonicalizeMode::Response { .. } => panic!("param ty in response: {c:?}"),
},
diff --git a/compiler/rustc_next_trait_solver/src/lib.rs b/compiler/rustc_next_trait_solver/src/lib.rs
index 92cdc28a37b4b..77f098e6f2649 100644
--- a/compiler/rustc_next_trait_solver/src/lib.rs
+++ b/compiler/rustc_next_trait_solver/src/lib.rs
@@ -12,5 +12,6 @@
pub mod canonicalizer;
pub mod coherence;
pub mod delegate;
+pub mod placeholder;
pub mod resolve;
pub mod solve;
diff --git a/compiler/rustc_next_trait_solver/src/placeholder.rs b/compiler/rustc_next_trait_solver/src/placeholder.rs
new file mode 100644
index 0000000000000..c88fb8defae7b
--- /dev/null
+++ b/compiler/rustc_next_trait_solver/src/placeholder.rs
@@ -0,0 +1,158 @@
+use core::panic;
+
+use rustc_type_ir::data_structures::IndexMap;
+use rustc_type_ir::inherent::*;
+use rustc_type_ir::{
+ self as ty, InferCtxtLike, Interner, TypeFoldable, TypeFolder, TypeSuperFoldable,
+ TypeVisitableExt,
+};
+
+pub struct BoundVarReplacer<'a, Infcx, I = <Infcx as InferCtxtLike>::Interner>
+where
+ Infcx: InferCtxtLike<Interner = I>,
+ I: Interner,
+{
+ infcx: &'a Infcx,
+ // These three maps track the bound variable that were replaced by placeholders. It might be
+ // nice to remove these since we already have the `kind` in the placeholder; we really just need
+ // the `var` (but we *could* bring that into scope if we were to track them as we pass them).
+ mapped_regions: IndexMap<I::PlaceholderRegion, I::BoundRegion>,
+ mapped_types: IndexMap<I::PlaceholderTy, I::BoundTy>,
+ mapped_consts: IndexMap<I::PlaceholderConst, I::BoundConst>,
+ // The current depth relative to *this* folding, *not* the entire normalization. In other words,
+ // the depth of binders we've passed here.
+ current_index: ty::DebruijnIndex,
+ // The `UniverseIndex` of the binding levels above us. These are optional, since we are lazy:
+ // we don't actually create a universe until we see a bound var we have to replace.
+ universe_indices: &'a mut Vec<Option<ty::UniverseIndex>>,
+}
+
+impl<'a, Infcx, I> BoundVarReplacer<'a, Infcx, I>
+where
+ Infcx: InferCtxtLike<Interner = I>,
+ I: Interner,
+{
+ /// Returns `Some` if we *were* able to replace bound vars. If there are any bound vars that
+ /// use a binding level above `universe_indices.len()`, we fail.
+ pub fn replace_bound_vars<T: TypeFoldable<I>>(
+ infcx: &'a Infcx,
+ universe_indices: &'a mut Vec<Option<ty::UniverseIndex>>,
+ value: T,
+ ) -> (
+ T,
+ IndexMap<I::PlaceholderRegion, I::BoundRegion>,
+ IndexMap<I::PlaceholderTy, I::BoundTy>,
+ IndexMap<I::PlaceholderConst, I::BoundConst>,
+ ) {
+ let mut replacer = BoundVarReplacer {
+ infcx,
+ mapped_regions: Default::default(),
+ mapped_types: Default::default(),
+ mapped_consts: Default::default(),
+ current_index: ty::INNERMOST,
+ universe_indices,
+ };
+
+ let value = value.fold_with(&mut replacer);
+
+ (value, replacer.mapped_regions, replacer.mapped_types, replacer.mapped_consts)
+ }
+
+ fn universe_for(&mut self, debruijn: ty::DebruijnIndex) -> ty::UniverseIndex {
+ let infcx = self.infcx;
+ let index =
+ self.universe_indices.len() + self.current_index.as_usize() - debruijn.as_usize() - 1;
+ let universe = self.universe_indices[index].unwrap_or_else(|| {
+ for i in self.universe_indices.iter_mut().take(index + 1) {
+ *i = i.or_else(|| Some(infcx.create_next_universe()))
+ }
+ self.universe_indices[index].unwrap()
+ });
+ universe
+ }
+}
+
+impl<Infcx, I> TypeFolder<I> for BoundVarReplacer<'_, Infcx, I>
+where
+ Infcx: InferCtxtLike<Interner = I>,
+ I: Interner,
+{
+ fn cx(&self) -> I {
+ self.infcx.cx()
+ }
+
+ fn fold_binder<T: TypeFoldable<I>>(&mut self, t: ty::Binder<I, T>) -> ty::Binder<I, T> {
+ self.current_index.shift_in(1);
+ let t = t.super_fold_with(self);
+ self.current_index.shift_out(1);
+ t
+ }
+
+ fn fold_region(&mut self, r: I::Region) -> I::Region {
+ match r.kind() {
+ ty::ReBound(debruijn, _)
+ if debruijn.as_usize()
+ >= self.current_index.as_usize() + self.universe_indices.len() =>
+ {
+ panic!(
+ "Bound vars {r:#?} outside of `self.universe_indices`: {:#?}",
+ self.universe_indices
+ );
+ }
+ ty::ReBound(debruijn, br) if debruijn >= self.current_index => {
+ let universe = self.universe_for(debruijn);
+ let p = PlaceholderLike::new(universe, br);
+ self.mapped_regions.insert(p, br);
+ Region::new_placeholder(self.cx(), p)
+ }
+ _ => r,
+ }
+ }
+
+ fn fold_ty(&mut self, t: I::Ty) -> I::Ty {
+ match t.kind() {
+ ty::Bound(debruijn, _)
+ if debruijn.as_usize() + 1
+ > self.current_index.as_usize() + self.universe_indices.len() =>
+ {
+ panic!(
+ "Bound vars {t:#?} outside of `self.universe_indices`: {:#?}",
+ self.universe_indices
+ );
+ }
+ ty::Bound(debruijn, bound_ty) if debruijn >= self.current_index => {
+ let universe = self.universe_for(debruijn);
+ let p = PlaceholderLike::new(universe, bound_ty);
+ self.mapped_types.insert(p, bound_ty);
+ Ty::new_placeholder(self.cx(), p)
+ }
+ _ if t.has_vars_bound_at_or_above(self.current_index) => t.super_fold_with(self),
+ _ => t,
+ }
+ }
+
+ fn fold_const(&mut self, ct: I::Const) -> I::Const {
+ match ct.kind() {
+ ty::ConstKind::Bound(debruijn, _)
+ if debruijn.as_usize() + 1
+ > self.current_index.as_usize() + self.universe_indices.len() =>
+ {
+ panic!(
+ "Bound vars {ct:#?} outside of `self.universe_indices`: {:#?}",
+ self.universe_indices
+ );
+ }
+ ty::ConstKind::Bound(debruijn, bound_const) if debruijn >= self.current_index => {
+ let universe = self.universe_for(debruijn);
+ let p = PlaceholderLike::new(universe, bound_const);
+ self.mapped_consts.insert(p, bound_const);
+ Const::new_placeholder(self.cx(), p)
+ }
+ _ => ct.super_fold_with(self),
+ }
+ }
+
+ fn fold_predicate(&mut self, p: I::Predicate) -> I::Predicate {
+ if p.has_vars_bound_at_or_above(self.current_index) { p.super_fold_with(self) } else { p }
+ }
+}
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 542e212e1bfb1..0c267feefbe6b 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs
@@ -1014,7 +1014,11 @@ where
return Ok(CandidateSource::ParamEnv(ParamEnvSource::NonGlobal));
}
- match assumption.visit_with(&mut FindParamInClause { ecx: self, param_env }) {
+ match assumption.visit_with(&mut FindParamInClause {
+ ecx: self,
+ param_env,
+ universes: vec![],
+ }) {
ControlFlow::Break(Err(NoSolution)) => Err(NoSolution),
ControlFlow::Break(Ok(())) => Ok(CandidateSource::ParamEnv(ParamEnvSource::NonGlobal)),
ControlFlow::Continue(()) => Ok(CandidateSource::ParamEnv(ParamEnvSource::Global)),
@@ -1025,6 +1029,7 @@ where
struct FindParamInClause<'a, 'b, D: SolverDelegate<Interner = I>, I: Interner> {
ecx: &'a mut EvalCtxt<'b, D>,
param_env: I::ParamEnv,
+ universes: Vec<Option<ty::UniverseIndex>>,
}
impl<D, I> TypeVisitor<I> for FindParamInClause<'_, '_, D, I>
@@ -1034,31 +1039,42 @@ where
{
type Result = ControlFlow<Result<(), NoSolution>>;
- fn visit_binder<T: TypeFoldable<I>>(&mut self, t: &ty::Binder<I, T>) -> Self::Result {
- self.ecx.enter_forall(t.clone(), |ecx, v| {
- v.visit_with(&mut FindParamInClause { ecx, param_env: self.param_env })
- })
+ fn visit_binder<T: TypeVisitable<I>>(&mut self, t: &ty::Binder<I, T>) -> Self::Result {
+ self.universes.push(None);
+ t.super_visit_with(self)?;
+ self.universes.pop();
+ ControlFlow::Continue(())
}
fn visit_ty(&mut self, ty: I::Ty) -> Self::Result {
+ let ty = self.ecx.replace_bound_vars(ty, &mut self.universes);
let Ok(ty) = self.ecx.structurally_normalize_ty(self.param_env, ty) else {
return ControlFlow::Break(Err(NoSolution));
};
- if let ty::Placeholder(_) = ty.kind() {
- ControlFlow::Break(Ok(()))
+ if let ty::Placeholder(p) = ty.kind() {
+ if p.universe() == ty::UniverseIndex::ROOT {
+ ControlFlow::Break(Ok(()))
+ } else {
+ ControlFlow::Continue(())
+ }
} else {
ty.super_visit_with(self)
}
}
fn visit_const(&mut self, ct: I::Const) -> Self::Result {
+ let ct = self.ecx.replace_bound_vars(ct, &mut self.universes);
let Ok(ct) = self.ecx.structurally_normalize_const(self.param_env, ct) else {
return ControlFlow::Break(Err(NoSolution));
};
- if let ty::ConstKind::Placeholder(_) = ct.kind() {
- ControlFlow::Break(Ok(()))
+ if let ty::ConstKind::Placeholder(p) = ct.kind() {
+ if p.universe() == ty::UniverseIndex::ROOT {
+ ControlFlow::Break(Ok(()))
+ } else {
+ ControlFlow::Continue(())
+ }
} else {
ct.super_visit_with(self)
}
@@ -1066,10 +1082,17 @@ where
fn visit_region(&mut self, r: I::Region) -> Self::Result {
match self.ecx.eager_resolve_region(r).kind() {
- ty::ReStatic | ty::ReError(_) => ControlFlow::Continue(()),
- ty::ReVar(_) | ty::RePlaceholder(_) => ControlFlow::Break(Ok(())),
- ty::ReErased | ty::ReEarlyParam(_) | ty::ReLateParam(_) | ty::ReBound(..) => {
- unreachable!()
+ ty::ReStatic | ty::ReError(_) | ty::ReBound(..) => ControlFlow::Continue(()),
+ ty::RePlaceholder(p) => {
+ if p.universe() == ty::UniverseIndex::ROOT {
+ ControlFlow::Break(Ok(()))
+ } else {
+ ControlFlow::Continue(())
+ }
+ }
+ ty::ReVar(_) => ControlFlow::Break(Ok(())),
+ ty::ReErased | ty::ReEarlyParam(_) | ty::ReLateParam(_) => {
+ unreachable!("unexpected region in param-env clause")
}
}
}
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 345ece20b7e53..7ead0a6d6b776 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
@@ -19,6 +19,7 @@ use tracing::{debug, instrument, trace};
use super::has_only_region_constraints;
use crate::coherence;
use crate::delegate::SolverDelegate;
+use crate::placeholder::BoundVarReplacer;
use crate::solve::inspect::{self, ProofTreeBuilder};
use crate::solve::search_graph::SearchGraph;
use crate::solve::{
@@ -1232,6 +1233,14 @@ where
) -> Result<Certainty, NoSolution> {
self.delegate.is_transmutable(dst, src, assume)
}
+
+ pub(super) fn replace_bound_vars<T: TypeFoldable<I>>(
+ &self,
+ t: T,
+ universes: &mut Vec<Option<ty::UniverseIndex>>,
+ ) -> T {
+ BoundVarReplacer::replace_bound_vars(&**self.delegate, universes, t).0
+ }
}
/// Eagerly replace aliases with inference variables, emitting `AliasRelate`
diff --git a/compiler/rustc_trait_selection/src/traits/query/normalize.rs b/compiler/rustc_trait_selection/src/traits/query/normalize.rs
index eb34cb10c68dd..a54eb80fedc25 100644
--- a/compiler/rustc_trait_selection/src/traits/query/normalize.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/normalize.rs
@@ -9,7 +9,7 @@ use rustc_macros::extension;
pub use rustc_middle::traits::query::NormalizationResult;
use rustc_middle::ty::{
self, FallibleTypeFolder, Ty, TyCtxt, TypeFoldable, TypeSuperFoldable, TypeSuperVisitable,
- TypeVisitableExt, TypeVisitor, TypingMode,
+ TypeVisitable, TypeVisitableExt, TypeVisitor, TypingMode,
};
use rustc_span::DUMMY_SP;
use tracing::{debug, info, instrument};
@@ -127,7 +127,7 @@ struct MaxEscapingBoundVarVisitor {
}
impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for MaxEscapingBoundVarVisitor {
- fn visit_binder<T: TypeFoldable<TyCtxt<'tcx>>>(&mut self, t: &ty::Binder<'tcx, T>) {
+ fn visit_binder<T: TypeVisitable<TyCtxt<'tcx>>>(&mut self, t: &ty::Binder<'tcx, T>) {
self.outer_index.shift_in(1);
t.super_visit_with(self);
self.outer_index.shift_out(1);
diff --git a/compiler/rustc_trait_selection/src/traits/util.rs b/compiler/rustc_trait_selection/src/traits/util.rs
index 035fd38c48aad..0723aebd5d225 100644
--- a/compiler/rustc_trait_selection/src/traits/util.rs
+++ b/compiler/rustc_trait_selection/src/traits/util.rs
@@ -1,4 +1,4 @@
-use std::collections::{BTreeMap, VecDeque};
+use std::collections::VecDeque;
use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
use rustc_hir::LangItem;
@@ -9,6 +9,7 @@ use rustc_middle::bug;
use rustc_middle::ty::{
self, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable, TypeVisitableExt,
};
+pub use rustc_next_trait_solver::placeholder::BoundVarReplacer;
use rustc_span::Span;
use smallvec::{SmallVec, smallvec};
use tracing::debug;
@@ -212,158 +213,12 @@ pub fn with_replaced_escaping_bound_vars<
}
}
-pub struct BoundVarReplacer<'a, 'tcx> {
- infcx: &'a InferCtxt<'tcx>,
- // These three maps track the bound variable that were replaced by placeholders. It might be
- // nice to remove these since we already have the `kind` in the placeholder; we really just need
- // the `var` (but we *could* bring that into scope if we were to track them as we pass them).
- mapped_regions: FxIndexMap<ty::PlaceholderRegion, ty::BoundRegion>,
- mapped_types: FxIndexMap<ty::PlaceholderType, ty::BoundTy>,
- mapped_consts: BTreeMap<ty::PlaceholderConst, ty::BoundVar>,
- // The current depth relative to *this* folding, *not* the entire normalization. In other words,
- // the depth of binders we've passed here.
- current_index: ty::DebruijnIndex,
- // The `UniverseIndex` of the binding levels above us. These are optional, since we are lazy:
- // we don't actually create a universe until we see a bound var we have to replace.
- universe_indices: &'a mut Vec<Option<ty::UniverseIndex>>,
-}
-
-impl<'a, 'tcx> BoundVarReplacer<'a, 'tcx> {
- /// Returns `Some` if we *were* able to replace bound vars. If there are any bound vars that
- /// use a binding level above `universe_indices.len()`, we fail.
- pub fn replace_bound_vars<T: TypeFoldable<TyCtxt<'tcx>>>(
- infcx: &'a InferCtxt<'tcx>,
- universe_indices: &'a mut Vec<Option<ty::UniverseIndex>>,
- value: T,
- ) -> (
- T,
- FxIndexMap<ty::PlaceholderRegion, ty::BoundRegion>,
- FxIndexMap<ty::PlaceholderType, ty::BoundTy>,
- BTreeMap<ty::PlaceholderConst, ty::BoundVar>,
- ) {
- let mapped_regions: FxIndexMap<ty::PlaceholderRegion, ty::BoundRegion> =
- FxIndexMap::default();
- let mapped_types: FxIndexMap<ty::PlaceholderType, ty::BoundTy> = FxIndexMap::default();
- let mapped_consts: BTreeMap<ty::PlaceholderConst, ty::BoundVar> = BTreeMap::new();
-
- let mut replacer = BoundVarReplacer {
- infcx,
- mapped_regions,
- mapped_types,
- mapped_consts,
- current_index: ty::INNERMOST,
- universe_indices,
- };
-
- let value = value.fold_with(&mut replacer);
-
- (value, replacer.mapped_regions, replacer.mapped_types, replacer.mapped_consts)
- }
-
- fn universe_for(&mut self, debruijn: ty::DebruijnIndex) -> ty::UniverseIndex {
- let infcx = self.infcx;
- let index =
- self.universe_indices.len() + self.current_index.as_usize() - debruijn.as_usize() - 1;
- let universe = self.universe_indices[index].unwrap_or_else(|| {
- for i in self.universe_indices.iter_mut().take(index + 1) {
- *i = i.or_else(|| Some(infcx.create_next_universe()))
- }
- self.universe_indices[index].unwrap()
- });
- universe
- }
-}
-
-impl<'tcx> TypeFolder<TyCtxt<'tcx>> for BoundVarReplacer<'_, 'tcx> {
- fn cx(&self) -> TyCtxt<'tcx> {
- self.infcx.tcx
- }
-
- fn fold_binder<T: TypeFoldable<TyCtxt<'tcx>>>(
- &mut self,
- t: ty::Binder<'tcx, T>,
- ) -> ty::Binder<'tcx, T> {
- self.current_index.shift_in(1);
- let t = t.super_fold_with(self);
- self.current_index.shift_out(1);
- t
- }
-
- fn fold_region(&mut self, r: ty::Region<'tcx>) -> ty::Region<'tcx> {
- match r.kind() {
- ty::ReBound(debruijn, _)
- if debruijn.as_usize()
- >= self.current_index.as_usize() + self.universe_indices.len() =>
- {
- bug!(
- "Bound vars {r:#?} outside of `self.universe_indices`: {:#?}",
- self.universe_indices
- );
- }
- ty::ReBound(debruijn, br) if debruijn >= self.current_index => {
- let universe = self.universe_for(debruijn);
- let p = ty::PlaceholderRegion { universe, bound: br };
- self.mapped_regions.insert(p, br);
- ty::Region::new_placeholder(self.infcx.tcx, p)
- }
- _ => r,
- }
- }
-
- fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
- match *t.kind() {
- ty::Bound(debruijn, _)
- if debruijn.as_usize() + 1
- > self.current_index.as_usize() + self.universe_indices.len() =>
- {
- bug!(
- "Bound vars {t:#?} outside of `self.universe_indices`: {:#?}",
- self.universe_indices
- );
- }
- ty::Bound(debruijn, bound_ty) if debruijn >= self.current_index => {
- let universe = self.universe_for(debruijn);
- let p = ty::PlaceholderType { universe, bound: bound_ty };
- self.mapped_types.insert(p, bound_ty);
- Ty::new_placeholder(self.infcx.tcx, p)
- }
- _ if t.has_vars_bound_at_or_above(self.current_index) => t.super_fold_with(self),
- _ => t,
- }
- }
-
- fn fold_const(&mut self, ct: ty::Const<'tcx>) -> ty::Const<'tcx> {
- match ct.kind() {
- ty::ConstKind::Bound(debruijn, _)
- if debruijn.as_usize() + 1
- > self.current_index.as_usize() + self.universe_indices.len() =>
- {
- bug!(
- "Bound vars {ct:#?} outside of `self.universe_indices`: {:#?}",
- self.universe_indices
- );
- }
- ty::ConstKind::Bound(debruijn, bound_const) if debruijn >= self.current_index => {
- let universe = self.universe_for(debruijn);
- let p = ty::PlaceholderConst { universe, bound: bound_const };
- self.mapped_consts.insert(p, bound_const);
- ty::Const::new_placeholder(self.infcx.tcx, p)
- }
- _ => ct.super_fold_with(self),
- }
- }
-
- fn fold_predicate(&mut self, p: ty::Predicate<'tcx>) -> ty::Predicate<'tcx> {
- if p.has_vars_bound_at_or_above(self.current_index) { p.super_fold_with(self) } else { p }
- }
-}
-
/// The inverse of [`BoundVarReplacer`]: replaces placeholders with the bound vars from which they came.
pub struct PlaceholderReplacer<'a, 'tcx> {
infcx: &'a InferCtxt<'tcx>,
mapped_regions: FxIndexMap<ty::PlaceholderRegion, ty::BoundRegion>,
mapped_types: FxIndexMap<ty::PlaceholderType, ty::BoundTy>,
- mapped_consts: BTreeMap<ty::PlaceholderConst, ty::BoundVar>,
+ mapped_consts: FxIndexMap<ty::PlaceholderConst, ty::BoundVar>,
universe_indices: &'a [Option<ty::UniverseIndex>],
current_index: ty::DebruijnIndex,
}
@@ -373,7 +228,7 @@ impl<'a, 'tcx> PlaceholderReplacer<'a, 'tcx> {
infcx: &'a InferCtxt<'tcx>,
mapped_regions: FxIndexMap<ty::PlaceholderRegion, ty::BoundRegion>,
mapped_types: FxIndexMap<ty::PlaceholderType, ty::BoundTy>,
- mapped_consts: BTreeMap<ty::PlaceholderConst, ty::BoundVar>,
+ mapped_consts: FxIndexMap<ty::PlaceholderConst, ty::BoundVar>,
universe_indices: &'a [Option<ty::UniverseIndex>],
value: T,
) -> T {
diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs
index 79ac622df32aa..11becea998c84 100644
--- a/compiler/rustc_ty_utils/src/ty.rs
+++ b/compiler/rustc_ty_utils/src/ty.rs
@@ -7,8 +7,7 @@ use rustc_infer::infer::TyCtxtInferExt;
use rustc_middle::bug;
use rustc_middle::query::Providers;
use rustc_middle::ty::{
- self, Ty, TyCtxt, TypeFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitor, Upcast,
- fold_regions,
+ self, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitor, Upcast, fold_regions,
};
use rustc_span::DUMMY_SP;
use rustc_span::def_id::{CRATE_DEF_ID, DefId, LocalDefId};
@@ -186,7 +185,7 @@ struct ImplTraitInTraitFinder<'a, 'tcx> {
}
impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for ImplTraitInTraitFinder<'_, 'tcx> {
- fn visit_binder<T: TypeFoldable<TyCtxt<'tcx>>>(&mut self, binder: &ty::Binder<'tcx, T>) {
+ fn visit_binder<T: TypeVisitable<TyCtxt<'tcx>>>(&mut self, binder: &ty::Binder<'tcx, T>) {
self.depth.shift_in(1);
binder.super_visit_with(self);
self.depth.shift_out(1);
diff --git a/compiler/rustc_type_ir/Cargo.toml b/compiler/rustc_type_ir/Cargo.toml
index 83d3d78298e60..4bd7bfe79befe 100644
--- a/compiler/rustc_type_ir/Cargo.toml
+++ b/compiler/rustc_type_ir/Cargo.toml
@@ -9,7 +9,7 @@ bitflags = "2.4.1"
derive-where = "1.2.7"
ena = "0.14.3"
indexmap = "2.0.0"
-rustc-hash = "1.1.0"
+rustc-hash = "2.0.0"
rustc_ast_ir = { path = "../rustc_ast_ir", default-features = false }
rustc_data_structures = { path = "../rustc_data_structures", optional = true }
rustc_index = { path = "../rustc_index", default-features = false }
diff --git a/compiler/rustc_type_ir/src/binder.rs b/compiler/rustc_type_ir/src/binder.rs
index 55c0a3bba9f2b..927a2ce84ea73 100644
--- a/compiler/rustc_type_ir/src/binder.rs
+++ b/compiler/rustc_type_ir/src/binder.rs
@@ -128,7 +128,7 @@ impl<I: Interner, T: TypeFoldable<I>> TypeFoldable<I> for Binder<I, T> {
}
}
-impl<I: Interner, T: TypeFoldable<I>> TypeVisitable<I> for Binder<I, T> {
+impl<I: Interner, T: TypeVisitable<I>> TypeVisitable<I> for Binder<I, T> {
fn visit_with<V: TypeVisitor<I>>(&self, visitor: &mut V) -> V::Result {
visitor.visit_binder(self)
}
@@ -147,7 +147,7 @@ impl<I: Interner, T: TypeFoldable<I>> TypeSuperFoldable<I> for Binder<I, T> {
}
}
-impl<I: Interner, T: TypeFoldable<I>> TypeSuperVisitable<I> for Binder<I, T> {
+impl<I: Interner, T: TypeVisitable<I>> TypeSuperVisitable<I> for Binder<I, T> {
fn super_visit_with<V: TypeVisitor<I>>(&self, visitor: &mut V) -> V::Result {
self.as_ref().skip_binder().visit_with(visitor)
}
@@ -292,7 +292,7 @@ impl<I: Interner> ValidateBoundVars<I> {
impl<I: Interner> TypeVisitor<I> for ValidateBoundVars<I> {
type Result = ControlFlow<()>;
- fn visit_binder<T: TypeFoldable<I>>(&mut self, t: &Binder<I, T>) -> Self::Result {
+ fn visit_binder<T: TypeVisitable<I>>(&mut self, t: &Binder<I, T>) -> Self::Result {
self.binder_index.shift_in(1);
let result = t.super_visit_with(self);
self.binder_index.shift_out(1);
diff --git a/compiler/rustc_type_ir/src/inherent.rs b/compiler/rustc_type_ir/src/inherent.rs
index fa88bcb891a9c..436ab9f80b6a1 100644
--- a/compiler/rustc_type_ir/src/inherent.rs
+++ b/compiler/rustc_type_ir/src/inherent.rs
@@ -228,6 +228,8 @@ pub trait Region<I: Interner<Region = Self>>:
fn new_static(interner: I) -> Self;
+ fn new_placeholder(interner: I, var: I::PlaceholderRegion) -> Self;
+
fn is_bound(self) -> bool {
matches!(self.kind(), ty::ReBound(..))
}
@@ -254,6 +256,8 @@ pub trait Const<I: Interner<Const = Self>>:
fn new_anon_bound(interner: I, debruijn: ty::DebruijnIndex, var: ty::BoundVar) -> Self;
+ fn new_placeholder(interner: I, param: I::PlaceholderConst) -> Self;
+
fn new_unevaluated(interner: I, uv: ty::UnevaluatedConst<I>) -> Self;
fn new_expr(interner: I, expr: I::ExprConst) -> Self;
@@ -524,13 +528,14 @@ pub trait Clauses<I: Interner<Clauses = Self>>:
}
/// Common capabilities of placeholder kinds
-pub trait PlaceholderLike: Copy + Debug + Hash + Eq {
+pub trait PlaceholderLike<I: Interner>: Copy + Debug + Hash + Eq {
fn universe(self) -> ty::UniverseIndex;
fn var(self) -> ty::BoundVar;
+ type Bound: BoundVarLike<I>;
+ fn new(ui: ty::UniverseIndex, bound: Self::Bound) -> Self;
+ fn new_anon(ui: ty::UniverseIndex, var: ty::BoundVar) -> Self;
fn with_updated_universe(self, ui: ty::UniverseIndex) -> Self;
-
- fn new(ui: ty::UniverseIndex, var: ty::BoundVar) -> Self;
}
pub trait IntoKind {
@@ -539,13 +544,13 @@ pub trait IntoKind {
fn kind(self) -> Self::Kind;
}
-pub trait BoundVarLike<I: Interner> {
+pub trait BoundVarLike<I: Interner>: Copy + Debug + Hash + Eq {
fn var(self) -> ty::BoundVar;
fn assert_eq(self, var: I::BoundVarKind);
}
-pub trait ParamLike {
+pub trait ParamLike: Copy + Debug + Hash + Eq {
fn index(self) -> u32;
}
diff --git a/compiler/rustc_type_ir/src/interner.rs b/compiler/rustc_type_ir/src/interner.rs
index cc0925b2c32a4..033d2579678ca 100644
--- a/compiler/rustc_type_ir/src/interner.rs
+++ b/compiler/rustc_type_ir/src/interner.rs
@@ -103,9 +103,9 @@ pub trait Interner:
type Ty: Ty<Self>;
type Tys: Tys<Self>;
type FnInputTys: Copy + Debug + Hash + Eq + SliceLike<Item = Self::Ty> + TypeVisitable<Self>;
- type ParamTy: Copy + Debug + Hash + Eq + ParamLike;
- type BoundTy: Copy + Debug + Hash + Eq + BoundVarLike<Self>;
- type PlaceholderTy: PlaceholderLike;
+ type ParamTy: ParamLike;
+ type BoundTy: BoundVarLike<Self>;
+ type PlaceholderTy: PlaceholderLike<Self, Bound = Self::BoundTy>;
// Things stored inside of tys
type ErrorGuaranteed: Copy + Debug + Hash + Eq;
@@ -131,19 +131,19 @@ pub trait Interner:
// Kinds of consts
type Const: Const<Self>;
- type PlaceholderConst: PlaceholderLike;
type ParamConst: Copy + Debug + Hash + Eq + ParamLike;
- type BoundConst: Copy + Debug + Hash + Eq + BoundVarLike<Self>;
+ type BoundConst: BoundVarLike<Self>;
+ type PlaceholderConst: PlaceholderLike<Self, Bound = Self::BoundConst>;
type ValueConst: ValueConst<Self>;
type ExprConst: ExprConst<Self>;
type ValTree: Copy + Debug + Hash + Eq;
// Kinds of regions
type Region: Region<Self>;
- type EarlyParamRegion: Copy + Debug + Hash + Eq + ParamLike;
+ type EarlyParamRegion: ParamLike;
type LateParamRegion: Copy + Debug + Hash + Eq;
- type BoundRegion: Copy + Debug + Hash + Eq + BoundVarLike<Self>;
- type PlaceholderRegion: PlaceholderLike;
+ type BoundRegion: BoundVarLike<Self>;
+ type PlaceholderRegion: PlaceholderLike<Self, Bound = Self::BoundRegion>;
// Predicates
type ParamEnv: ParamEnv<Self>;
diff --git a/compiler/rustc_type_ir/src/ty_kind/closure.rs b/compiler/rustc_type_ir/src/ty_kind/closure.rs
index 8ba985d2d1931..d1ca9bdb7fbd1 100644
--- a/compiler/rustc_type_ir/src/ty_kind/closure.rs
+++ b/compiler/rustc_type_ir/src/ty_kind/closure.rs
@@ -342,7 +342,7 @@ struct HasRegionsBoundAt {
// FIXME: Could be optimized to not walk into components with no escaping bound vars.
impl<I: Interner> TypeVisitor<I> for HasRegionsBoundAt {
type Result = ControlFlow<()>;
- fn visit_binder<T: TypeFoldable<I>>(&mut self, t: &ty::Binder<I, T>) -> Self::Result {
+ fn visit_binder<T: TypeVisitable<I>>(&mut self, t: &ty::Binder<I, T>) -> Self::Result {
self.binder.shift_in(1);
t.super_visit_with(self)?;
self.binder.shift_out(1);
diff --git a/compiler/rustc_type_ir/src/visit.rs b/compiler/rustc_type_ir/src/visit.rs
index fc3864dd5ae6e..a96ac97f785d4 100644
--- a/compiler/rustc_type_ir/src/visit.rs
+++ b/compiler/rustc_type_ir/src/visit.rs
@@ -52,7 +52,7 @@ use smallvec::SmallVec;
use thin_vec::ThinVec;
use crate::inherent::*;
-use crate::{self as ty, Interner, TypeFlags, TypeFoldable};
+use crate::{self as ty, Interner, TypeFlags};
/// This trait is implemented for every type that can be visited,
/// providing the skeleton of the traversal.
@@ -94,7 +94,7 @@ pub trait TypeVisitor<I: Interner>: Sized {
#[cfg(not(feature = "nightly"))]
type Result: VisitorResult;
- fn visit_binder<T: TypeFoldable<I>>(&mut self, t: &ty::Binder<I, T>) -> Self::Result {
+ fn visit_binder<T: TypeVisitable<I>>(&mut self, t: &ty::Binder<I, T>) -> Self::Result {
t.super_visit_with(self)
}
@@ -401,7 +401,7 @@ impl std::fmt::Debug for HasTypeFlagsVisitor {
impl<I: Interner> TypeVisitor<I> for HasTypeFlagsVisitor {
type Result = ControlFlow<FoundFlags>;
- fn visit_binder<T: TypeFoldable<I>>(&mut self, t: &ty::Binder<I, T>) -> Self::Result {
+ fn visit_binder<T: TypeVisitable<I>>(&mut self, t: &ty::Binder<I, T>) -> Self::Result {
// If we're looking for the HAS_BINDER_VARS flag, check if the
// binder has vars. This won't be present in the binder's bound
// value, so we need to check here too.
@@ -510,7 +510,7 @@ struct HasEscapingVarsVisitor {
impl<I: Interner> TypeVisitor<I> for HasEscapingVarsVisitor {
type Result = ControlFlow<FoundEscapingVars>;
- fn visit_binder<T: TypeFoldable<I>>(&mut self, t: &ty::Binder<I, T>) -> Self::Result {
+ fn visit_binder<T: TypeVisitable<I>>(&mut self, t: &ty::Binder<I, T>) -> Self::Result {
self.outer_index.shift_in(1);
let result = t.super_visit_with(self);
self.outer_index.shift_out(1);
diff --git a/src/tools/clippy/clippy_utils/src/ty/mod.rs b/src/tools/clippy/clippy_utils/src/ty/mod.rs
index 1f0a0f2b02ac0..32a992ccc2d7b 100644
--- a/src/tools/clippy/clippy_utils/src/ty/mod.rs
+++ b/src/tools/clippy/clippy_utils/src/ty/mod.rs
@@ -20,7 +20,7 @@ use rustc_middle::traits::EvaluationResult;
use rustc_middle::ty::layout::ValidityRequirement;
use rustc_middle::ty::{
self, AdtDef, AliasTy, AssocItem, AssocTag, Binder, BoundRegion, FnSig, GenericArg, GenericArgKind, GenericArgsRef,
- GenericParamDefKind, IntTy, Region, RegionKind, TraitRef, Ty, TyCtxt, TypeFoldable, TypeSuperVisitable,
+ GenericParamDefKind, IntTy, Region, RegionKind, TraitRef, Ty, TyCtxt, TypeSuperVisitable,
TypeVisitable, TypeVisitableExt, TypeVisitor, UintTy, Upcast, VariantDef, VariantDiscr,
};
use rustc_span::symbol::Ident;
@@ -853,7 +853,7 @@ pub fn for_each_top_level_late_bound_region<B>(
ControlFlow::Continue(())
}
}
- fn visit_binder<T: TypeFoldable<TyCtxt<'tcx>>>(&mut self, t: &Binder<'tcx, T>) -> Self::Result {
+ fn visit_binder<T: TypeVisitable<TyCtxt<'tcx>>>(&mut self, t: &Binder<'tcx, T>) -> Self::Result {
self.index += 1;
let res = t.super_visit_with(self);
self.index -= 1;