mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

tcx -> cx in rustc_type_ir

Browse Source
This commit is contained in:
Michael Goulet 2024-07-16 00:06:30 -04:00
parent a6510507e7
commit 8d90f442ca
14 changed files with 149 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
compiler/rustc_type_ir/src/binder.rs
View File

@ -49,10 +49,10 @@ impl<I: Interner, U: Interner, T> Lift<U> for Binder<I, T>
{
type Lifted = Binder<U, T::Lifted>;
fn lift_to_interner(self, tcx: U) -> Option<Self::Lifted> {
fn lift_to_interner(self, cx: U) -> Option<Self::Lifted> {
Some(Binder {
value: self.value.lift_to_interner(tcx)?,
bound_vars: self.bound_vars.lift_to_interner(tcx)?,
value: self.value.lift_to_interner(cx)?,
bound_vars: self.bound_vars.lift_to_interner(cx)?,
})
}
}
@ -439,11 +439,11 @@ impl<I: Interner, Iter: IntoIterator> EarlyBinder<I, Iter>
where
Iter::Item: TypeFoldable<I>,
{
pub fn iter_instantiated<A>(self, tcx: I, args: A) -> IterInstantiated<I, Iter, A>
pub fn iter_instantiated<A>(self, cx: I, args: A) -> IterInstantiated<I, Iter, A>
where
A: SliceLike<Item = I::GenericArg>,
{
IterInstantiated { it: self.value.into_iter(), tcx, args }
IterInstantiated { it: self.value.into_iter(), cx, args }
}
/// Similar to [`instantiate_identity`](EarlyBinder::instantiate_identity),
@ -455,7 +455,7 @@ pub fn iter_identity(self) -> Iter::IntoIter {
pub struct IterInstantiated<I: Interner, Iter: IntoIterator, A> {
it: Iter::IntoIter,
tcx: I,
cx: I,
args: A,
}
@ -469,7 +469,7 @@ impl<I: Interner, Iter: IntoIterator, A> Iterator for IterInstantiated<I, Iter,
fn next(&mut self) -> Option<Self::Item> {
Some(
EarlyBinder { value: self.it.next()?, _tcx: PhantomData }
.instantiate(self.tcx, self.args),
.instantiate(self.cx, self.args),
)
}
@ -487,7 +487,7 @@ impl<I: Interner, Iter: IntoIterator, A> DoubleEndedIterator for IterInstantiate
fn next_back(&mut self) -> Option<Self::Item> {
Some(
EarlyBinder { value: self.it.next_back()?, _tcx: PhantomData }
.instantiate(self.tcx, self.args),
.instantiate(self.cx, self.args),
)
}
}
@ -507,10 +507,10 @@ impl<'s, I: Interner, Iter: IntoIterator> EarlyBinder<I, Iter>
{
pub fn iter_instantiated_copied(
self,
tcx: I,
cx: I,
args: &'s [I::GenericArg],
) -> IterInstantiatedCopied<'s, I, Iter> {
IterInstantiatedCopied { it: self.value.into_iter(), tcx, args }
IterInstantiatedCopied { it: self.value.into_iter(), cx, args }
}
/// Similar to [`instantiate_identity`](EarlyBinder::instantiate_identity),
@ -522,7 +522,7 @@ pub fn iter_identity_copied(self) -> impl Iterator<Item = <Iter::Item as Deref>:
pub struct IterInstantiatedCopied<'a, I: Interner, Iter: IntoIterator> {
it: Iter::IntoIter,
tcx: I,
cx: I,
args: &'a [I::GenericArg],
}
@ -535,7 +535,7 @@ impl<I: Interner, Iter: IntoIterator> Iterator for IterInstantiatedCopied<'_, I,
fn next(&mut self) -> Option<Self::Item> {
self.it.next().map(|value| {
EarlyBinder { value: *value, _tcx: PhantomData }.instantiate(self.tcx, self.args)
EarlyBinder { value: *value, _tcx: PhantomData }.instantiate(self.cx, self.args)
})
}
@ -552,7 +552,7 @@ impl<I: Interner, Iter: IntoIterator> DoubleEndedIterator for IterInstantiatedCo
{
fn next_back(&mut self) -> Option<Self::Item> {
self.it.next_back().map(|value| {
EarlyBinder { value: *value, _tcx: PhantomData }.instantiate(self.tcx, self.args)
EarlyBinder { value: *value, _tcx: PhantomData }.instantiate(self.cx, self.args)
})
}
}
@ -589,11 +589,11 @@ fn size_hint(&self) -> (usize, Option<usize>) {
}
impl<I: Interner, T: TypeFoldable<I>> ty::EarlyBinder<I, T> {
pub fn instantiate<A>(self, tcx: I, args: A) -> T
pub fn instantiate<A>(self, cx: I, args: A) -> T
where
A: SliceLike<Item = I::GenericArg>,
{
let mut folder = ArgFolder { tcx, args: args.as_slice(), binders_passed: 0 };
let mut folder = ArgFolder { cx, args: args.as_slice(), binders_passed: 0 };
self.value.fold_with(&mut folder)
}
@ -619,7 +619,7 @@ pub fn no_bound_vars(self) -> Option<T> {
// The actual instantiation engine itself is a type folder.
struct ArgFolder<'a, I: Interner> {
tcx: I,
cx: I,
args: &'a [I::GenericArg],
/// Number of region binders we have passed through while doing the instantiation
@ -629,7 +629,7 @@ struct ArgFolder<'a, I: Interner> {
impl<'a, I: Interner> TypeFolder<I> for ArgFolder<'a, I> {
#[inline]
fn cx(&self) -> I {
self.tcx
self.cx
}
fn fold_binder<T: TypeFoldable<I>>(&mut self, t: ty::Binder<I, T>) -> ty::Binder<I, T> {
@ -858,6 +858,6 @@ fn shift_region_through_binders(&self, region: I::Region) -> I::Region {
if self.binders_passed == 0 || !region.has_escaping_bound_vars() {
return region;
}
ty::fold::shift_region(self.tcx, region, self.binders_passed)
ty::fold::shift_region(self.cx, region, self.binders_passed)
}
}

12
compiler/rustc_type_ir/src/canonical.rs
View File

@ -330,25 +330,25 @@ pub fn is_identity_modulo_regions(&self) -> bool {
// Given a list of canonical variables, construct a set of values which are
// the identity response.
pub fn make_identity(tcx: I, infos: I::CanonicalVars) -> CanonicalVarValues<I> {
pub fn make_identity(cx: I, infos: I::CanonicalVars) -> CanonicalVarValues<I> {
CanonicalVarValues {
var_values: tcx.mk_args_from_iter(infos.iter().enumerate().map(
var_values: cx.mk_args_from_iter(infos.iter().enumerate().map(
|(i, info)| -> I::GenericArg {
match info.kind {
CanonicalVarKind::Ty(_) | CanonicalVarKind::PlaceholderTy(_) => {
Ty::new_anon_bound(tcx, ty::INNERMOST, ty::BoundVar::from_usize(i))
Ty::new_anon_bound(cx, ty::INNERMOST, ty::BoundVar::from_usize(i))
.into()
}
CanonicalVarKind::Region(_) | CanonicalVarKind::PlaceholderRegion(_) => {
Region::new_anon_bound(tcx, ty::INNERMOST, ty::BoundVar::from_usize(i))
Region::new_anon_bound(cx, ty::INNERMOST, ty::BoundVar::from_usize(i))
.into()
}
CanonicalVarKind::Effect => {
Const::new_anon_bound(tcx, ty::INNERMOST, ty::BoundVar::from_usize(i))
Const::new_anon_bound(cx, ty::INNERMOST, ty::BoundVar::from_usize(i))
.into()
}
CanonicalVarKind::Const(_) | CanonicalVarKind::PlaceholderConst(_) => {
Const::new_anon_bound(tcx, ty::INNERMOST, ty::BoundVar::from_usize(i))
Const::new_anon_bound(cx, ty::INNERMOST, ty::BoundVar::from_usize(i))
.into()
}
}

20
compiler/rustc_type_ir/src/effects.rs
View File

@ -10,38 +10,38 @@ pub enum EffectKind {
}
impl EffectKind {
pub fn try_from_def_id<I: Interner>(tcx: I, def_id: I::DefId) -> Option<EffectKind> {
if tcx.is_lang_item(def_id, EffectsMaybe) {
pub fn try_from_def_id<I: Interner>(cx: I, def_id: I::DefId) -> Option<EffectKind> {
if cx.is_lang_item(def_id, EffectsMaybe) {
Some(EffectKind::Maybe)
} else if tcx.is_lang_item(def_id, EffectsRuntime) {
} else if cx.is_lang_item(def_id, EffectsRuntime) {
Some(EffectKind::Runtime)
} else if tcx.is_lang_item(def_id, EffectsNoRuntime) {
} else if cx.is_lang_item(def_id, EffectsNoRuntime) {
Some(EffectKind::NoRuntime)
} else {
None
}
}
pub fn to_def_id<I: Interner>(self, tcx: I) -> I::DefId {
pub fn to_def_id<I: Interner>(self, cx: I) -> I::DefId {
let lang_item = match self {
EffectKind::Maybe => EffectsMaybe,
EffectKind::NoRuntime => EffectsNoRuntime,
EffectKind::Runtime => EffectsRuntime,
};
tcx.require_lang_item(lang_item)
cx.require_lang_item(lang_item)
}
pub fn try_from_ty<I: Interner>(tcx: I, ty: I::Ty) -> Option<EffectKind> {
pub fn try_from_ty<I: Interner>(cx: I, ty: I::Ty) -> Option<EffectKind> {
if let crate::Adt(def, _) = ty.kind() {
Self::try_from_def_id(tcx, def.def_id())
Self::try_from_def_id(cx, def.def_id())
} else {
None
}
}
pub fn to_ty<I: Interner>(self, tcx: I) -> I::Ty {
I::Ty::new_adt(tcx, tcx.adt_def(self.to_def_id(tcx)), Default::default())
pub fn to_ty<I: Interner>(self, cx: I) -> I::Ty {
I::Ty::new_adt(cx, cx.adt_def(self.to_def_id(cx)), Default::default())
}
/// Returns an intersection between two effect kinds. If one effect kind

8
compiler/rustc_type_ir/src/elaborate.rs
View File

@ -258,17 +258,17 @@ pub fn supertrait_def_ids<I: Interner>(
}
pub fn supertraits<I: Interner>(
tcx: I,
cx: I,
trait_ref: ty::Binder<I, ty::TraitRef<I>>,
) -> FilterToTraits<I, Elaborator<I, I::Clause>> {
elaborate(tcx, [trait_ref.upcast(tcx)]).filter_only_self().filter_to_traits()
elaborate(cx, [trait_ref.upcast(cx)]).filter_only_self().filter_to_traits()
}
pub fn transitive_bounds<I: Interner>(
tcx: I,
cx: I,
trait_refs: impl Iterator<Item = ty::Binder<I, ty::TraitRef<I>>>,
) -> FilterToTraits<I, Elaborator<I, I::Clause>> {
elaborate(tcx, trait_refs.map(|trait_ref| trait_ref.upcast(tcx)))
elaborate(cx, trait_refs.map(|trait_ref| trait_ref.upcast(cx)))
.filter_only_self()
.filter_to_traits()
}

6
compiler/rustc_type_ir/src/fast_reject.rs
View File

@ -105,7 +105,7 @@ pub enum TreatParams {
///
/// ¹ meaning that if the outermost layers are different, then the whole types are also different.
pub fn simplify_type<I: Interner>(
tcx: I,
cx: I,
ty: I::Ty,
treat_params: TreatParams,
) -> Option<SimplifiedType<I::DefId>> {
@ -119,10 +119,10 @@ pub fn simplify_type<I: Interner>(
ty::Str => Some(SimplifiedType::Str),
ty::Array(..) => Some(SimplifiedType::Array),
ty::Slice(..) => Some(SimplifiedType::Slice),
ty::Pat(ty, ..) => simplify_type(tcx, ty, treat_params),
ty::Pat(ty, ..) => simplify_type(cx, ty, treat_params),
ty::RawPtr(_, mutbl) => Some(SimplifiedType::Ptr(mutbl)),
ty::Dynamic(trait_info, ..) => match trait_info.principal_def_id() {
Some(principal_def_id) if !tcx.trait_is_auto(principal_def_id) => {
Some(principal_def_id) if !cx.trait_is_auto(principal_def_id) => {
Some(SimplifiedType::Trait(principal_def_id))
}
_ => Some(SimplifiedType::MarkerTraitObject),

22
compiler/rustc_type_ir/src/fold.rs
View File

@ -345,20 +345,20 @@ fn try_fold_with<F: FallibleTypeFolder<I>>(self, folder: &mut F) -> Result<Self,
// `rustc_middle/src/ty/generic_args.rs` for more details.
struct Shifter<I: Interner> {
tcx: I,
cx: I,
current_index: ty::DebruijnIndex,
amount: u32,
}
impl<I: Interner> Shifter<I> {
pub fn new(tcx: I, amount: u32) -> Self {
Shifter { tcx, current_index: ty::INNERMOST, amount }
pub fn new(cx: I, amount: u32) -> Self {
Shifter { cx, current_index: ty::INNERMOST, amount }
}
}
impl<I: Interner> TypeFolder<I> for Shifter<I> {
fn cx(&self) -> I {
self.tcx
self.cx
}
fn fold_binder<T: TypeFoldable<I>>(&mut self, t: ty::Binder<I, T>) -> ty::Binder<I, T> {
@ -372,7 +372,7 @@ fn fold_region(&mut self, r: I::Region) -> I::Region {
match r.kind() {
ty::ReBound(debruijn, br) if debruijn >= self.current_index => {
let debruijn = debruijn.shifted_in(self.amount);
Region::new_bound(self.tcx, debruijn, br)
Region::new_bound(self.cx, debruijn, br)
}
_ => r,
}
@ -382,7 +382,7 @@ fn fold_ty(&mut self, ty: I::Ty) -> I::Ty {
match ty.kind() {
ty::Bound(debruijn, bound_ty) if debruijn >= self.current_index => {
let debruijn = debruijn.shifted_in(self.amount);
Ty::new_bound(self.tcx, debruijn, bound_ty)
Ty::new_bound(self.cx, debruijn, bound_ty)
}
_ if ty.has_vars_bound_at_or_above(self.current_index) => ty.super_fold_with(self),
@ -394,7 +394,7 @@ fn fold_const(&mut self, ct: I::Const) -> I::Const {
match ct.kind() {
ty::ConstKind::Bound(debruijn, bound_ct) if debruijn >= self.current_index => {
let debruijn = debruijn.shifted_in(self.amount);
Const::new_bound(self.tcx, debruijn, bound_ct)
Const::new_bound(self.cx, debruijn, bound_ct)
}
_ => ct.super_fold_with(self),
}
@ -405,16 +405,16 @@ fn fold_predicate(&mut self, p: I::Predicate) -> I::Predicate {
}
}
pub fn shift_region<I: Interner>(tcx: I, region: I::Region, amount: u32) -> I::Region {
pub fn shift_region<I: Interner>(cx: I, region: I::Region, amount: u32) -> I::Region {
match region.kind() {
ty::ReBound(debruijn, br) if amount > 0 => {
Region::new_bound(tcx, debruijn.shifted_in(amount), br)
Region::new_bound(cx, debruijn.shifted_in(amount), br)
}
_ => region,
}
}
pub fn shift_vars<I: Interner, T>(tcx: I, value: T, amount: u32) -> T
pub fn shift_vars<I: Interner, T>(cx: I, value: T, amount: u32) -> T
where
T: TypeFoldable<I>,
{
@ -424,5 +424,5 @@ pub fn shift_vars<I: Interner, T>(tcx: I, value: T, amount: u32) -> T
return value;
}
value.fold_with(&mut Shifter::new(tcx, amount))
value.fold_with(&mut Shifter::new(cx, amount))
}

2
compiler/rustc_type_ir/src/inherent.rs
View File

@ -475,7 +475,7 @@ fn as_projection_clause(self) -> Option<ty::Binder<I, ty::ProjectionPredicate<I>
/// poly-trait-ref to supertraits that must hold if that
/// poly-trait-ref holds. This is slightly different from a normal
/// instantiation in terms of what happens with bound regions.
fn instantiate_supertrait(self, tcx: I, trait_ref: ty::Binder<I, ty::TraitRef<I>>) -> Self;
fn instantiate_supertrait(self, cx: I, trait_ref: ty::Binder<I, ty::TraitRef<I>>) -> Self;
}
/// Common capabilities of placeholder kinds

2
compiler/rustc_type_ir/src/lift.rs
View File

@ -17,5 +17,5 @@
/// e.g., `()` or `u8`, was interned in a different context.
pub trait Lift<I>: std::fmt::Debug {
type Lifted: std::fmt::Debug;
fn lift_to_interner(self, tcx: I) -> Option<Self::Lifted>;
fn lift_to_interner(self, cx: I) -> Option<Self::Lifted>;
}

10
compiler/rustc_type_ir/src/opaque_ty.rs
View File

@ -22,8 +22,8 @@ pub struct OpaqueTypeKey<I: Interner> {
}
impl<I: Interner> OpaqueTypeKey<I> {
pub fn iter_captured_args(self, tcx: I) -> impl Iterator<Item = (usize, I::GenericArg)> {
let variances = tcx.variances_of(self.def_id.into());
pub fn iter_captured_args(self, cx: I) -> impl Iterator<Item = (usize, I::GenericArg)> {
let variances = cx.variances_of(self.def_id.into());
std::iter::zip(self.args.iter(), variances.iter()).enumerate().filter_map(
|(i, (arg, v))| match (arg.kind(), v) {
(_, ty::Invariant) => Some((i, arg)),
@ -35,18 +35,18 @@ pub fn iter_captured_args(self, tcx: I) -> impl Iterator<Item = (usize, I::Gener
pub fn fold_captured_lifetime_args(
self,
tcx: I,
cx: I,
mut f: impl FnMut(I::Region) -> I::Region,
) -> Self {
let Self { def_id, args } = self;
let variances = tcx.variances_of(def_id.into());
let variances = cx.variances_of(def_id.into());
let args =
std::iter::zip(args.iter(), variances.iter()).map(|(arg, v)| match (arg.kind(), v) {
(ty::GenericArgKind::Lifetime(_), ty::Bivariant) => arg,
(ty::GenericArgKind::Lifetime(lt), _) => f(lt).into(),
_ => arg,
});
let args = tcx.mk_args_from_iter(args);
let args = cx.mk_args_from_iter(args);
Self { def_id, args }
}
}

14
compiler/rustc_type_ir/src/outlives.rs
View File

@ -54,15 +54,15 @@ pub enum Component<I: Interner> {
/// Push onto `out` all the things that must outlive `'a` for the condition
/// `ty0: 'a` to hold. Note that `ty0` must be a **fully resolved type**.
pub fn push_outlives_components<I: Interner>(
tcx: I,
cx: I,
ty: I::Ty,
out: &mut SmallVec<[Component<I>; 4]>,
) {
ty.visit_with(&mut OutlivesCollector { tcx, out, visited: Default::default() });
ty.visit_with(&mut OutlivesCollector { cx, out, visited: Default::default() });
}
struct OutlivesCollector<'a, I: Interner> {
tcx: I,
cx: I,
out: &'a mut SmallVec<[Component<I>; 4]>,
visited: SsoHashSet<I::Ty>,
}
@ -147,7 +147,7 @@ fn visit_ty(&mut self, ty: I::Ty) -> Self::Result {
// OutlivesProjectionComponents. Continue walking
// through and constrain Pi.
let mut subcomponents = smallvec![];
compute_alias_components_recursive(self.tcx, ty, &mut subcomponents);
compute_alias_components_recursive(self.cx, ty, &mut subcomponents);
self.out.push(Component::EscapingAlias(subcomponents.into_iter().collect()));
}
}
@ -206,7 +206,7 @@ fn visit_region(&mut self, lt: I::Region) -> Self::Result {
/// This should not be used to get the components of `parent` itself.
/// Use [push_outlives_components] instead.
pub fn compute_alias_components_recursive<I: Interner>(
tcx: I,
cx: I,
alias_ty: I::Ty,
out: &mut SmallVec<[Component<I>; 4]>,
) {
@ -215,9 +215,9 @@ pub fn compute_alias_components_recursive<I: Interner>(
};
let opt_variances =
if kind == ty::Opaque { Some(tcx.variances_of(alias_ty.def_id)) } else { None };
if kind == ty::Opaque { Some(cx.variances_of(alias_ty.def_id)) } else { None };
let mut visitor = OutlivesCollector { tcx, out, visited: Default::default() };
let mut visitor = OutlivesCollector { cx, out, visited: Default::default() };
for (index, child) in alias_ty.args.iter().enumerate() {
if opt_variances.and_then(|variances| variances.get(index)) == Some(ty::Bivariant) {

38
compiler/rustc_type_ir/src/predicate.rs
View File

@ -34,8 +34,8 @@ impl<I: Interner, U: Interner, A> Lift<U> for OutlivesPredicate<I, A>
{
type Lifted = OutlivesPredicate<U, A::Lifted>;
fn lift_to_interner(self, tcx: U) -> Option<Self::Lifted> {
Some(OutlivesPredicate(self.0.lift_to_interner(tcx)?, self.1.lift_to_interner(tcx)?))
fn lift_to_interner(self, cx: U) -> Option<Self::Lifted> {
Some(OutlivesPredicate(self.0.lift_to_interner(cx)?, self.1.lift_to_interner(cx)?))
}
}
@ -267,25 +267,23 @@ impl<I: Interner> ty::Binder<I, ExistentialPredicate<I>> {
/// Given an existential predicate like `?Self: PartialEq<u32>` (e.g., derived from `dyn PartialEq<u32>`),
/// and a concrete type `self_ty`, returns a full predicate where the existentially quantified variable `?Self`
/// has been replaced with `self_ty` (e.g., `self_ty: PartialEq<u32>`, in our example).
pub fn with_self_ty(&self, tcx: I, self_ty: I::Ty) -> I::Clause {
pub fn with_self_ty(&self, cx: I, self_ty: I::Ty) -> I::Clause {
match self.skip_binder() {
ExistentialPredicate::Trait(tr) => {
self.rebind(tr).with_self_ty(tcx, self_ty).upcast(tcx)
}
ExistentialPredicate::Trait(tr) => self.rebind(tr).with_self_ty(cx, self_ty).upcast(cx),
ExistentialPredicate::Projection(p) => {
self.rebind(p.with_self_ty(tcx, self_ty)).upcast(tcx)
self.rebind(p.with_self_ty(cx, self_ty)).upcast(cx)
}
ExistentialPredicate::AutoTrait(did) => {
let generics = tcx.generics_of(did);
let generics = cx.generics_of(did);
let trait_ref = if generics.count() == 1 {
ty::TraitRef::new(tcx, did, [self_ty])
ty::TraitRef::new(cx, did, [self_ty])
} else {
// If this is an ill-formed auto trait, then synthesize
// new error args for the missing generics.
let err_args = GenericArgs::extend_with_error(tcx, did, &[self_ty.into()]);
ty::TraitRef::new_from_args(tcx, did, err_args)
let err_args = GenericArgs::extend_with_error(cx, did, &[self_ty.into()]);
ty::TraitRef::new_from_args(cx, did, err_args)
};
self.rebind(trait_ref).upcast(tcx)
self.rebind(trait_ref).upcast(cx)
}
}
}
@ -345,8 +343,8 @@ pub fn def_id(&self) -> I::DefId {
/// we convert the principal trait-ref into a normal trait-ref,
/// you must give *some* self type. A common choice is `mk_err()`
/// or some placeholder type.
pub fn with_self_ty(&self, tcx: I, self_ty: I::Ty) -> ty::Binder<I, TraitRef<I>> {
self.map_bound(|trait_ref| trait_ref.with_self_ty(tcx, self_ty))
pub fn with_self_ty(&self, cx: I, self_ty: I::Ty) -> ty::Binder<I, TraitRef<I>> {
self.map_bound(|trait_ref| trait_ref.with_self_ty(cx, self_ty))
}
}
@ -406,8 +404,8 @@ pub fn erase_self_ty(interner: I, projection_predicate: ProjectionPredicate<I>)
}
impl<I: Interner> ty::Binder<I, ExistentialProjection<I>> {
pub fn with_self_ty(&self, tcx: I, self_ty: I::Ty) -> ty::Binder<I, ProjectionPredicate<I>> {
self.map_bound(|p| p.with_self_ty(tcx, self_ty))
pub fn with_self_ty(&self, cx: I, self_ty: I::Ty) -> ty::Binder<I, ProjectionPredicate<I>> {
self.map_bound(|p| p.with_self_ty(cx, self_ty))
}
pub fn item_def_id(&self) -> I::DefId {
@ -669,21 +667,21 @@ pub fn def_id(self) -> I::DefId {
impl<I: Interner> ty::Binder<I, ProjectionPredicate<I>> {
/// Returns the `DefId` of the trait of the associated item being projected.
#[inline]
pub fn trait_def_id(&self, tcx: I) -> I::DefId {
self.skip_binder().projection_term.trait_def_id(tcx)
pub fn trait_def_id(&self, cx: I) -> I::DefId {
self.skip_binder().projection_term.trait_def_id(cx)
}
/// Get the trait ref required for this projection to be well formed.
/// Note that for generic associated types the predicates of the associated
/// type also need to be checked.
#[inline]
pub fn required_poly_trait_ref(&self, tcx: I) -> ty::Binder<I, TraitRef<I>> {
pub fn required_poly_trait_ref(&self, cx: I) -> ty::Binder<I, TraitRef<I>> {
// Note: unlike with `TraitRef::to_poly_trait_ref()`,
// `self.0.trait_ref` is permitted to have escaping regions.
// This is because here `self` has a `Binder` and so does our
// return value, so we are preserving the number of binding
// levels.
self.map_bound(|predicate| predicate.projection_term.trait_ref(tcx))
self.map_bound(|predicate| predicate.projection_term.trait_ref(cx))
}
pub fn term(&self) -> ty::Binder<I, I::Term> {

89
compiler/rustc_type_ir/src/relate.rs
View File

@ -56,7 +56,7 @@ pub fn xform(self, other: VarianceDiagInfo<I>) -> VarianceDiagInfo<I> {
}
pub trait TypeRelation<I: Interner>: Sized {
fn tcx(&self) -> I;
fn cx(&self) -> I;
/// Returns a static string we can use for printouts.
fn tag(&self) -> &'static str;
@ -80,8 +80,8 @@ fn relate_item_args(
item_def_id, a_arg, b_arg
);
let tcx = self.tcx();
let opt_variances = tcx.variances_of(item_def_id);
let cx = self.cx();
let opt_variances = cx.variances_of(item_def_id);
relate_args_with_variances(self, item_def_id, opt_variances, a_arg, b_arg, true)
}
@ -128,7 +128,7 @@ pub fn relate_args_invariantly<I: Interner, R: TypeRelation<I>>(
a_arg: I::GenericArgs,
b_arg: I::GenericArgs,
) -> RelateResult<I, I::GenericArgs> {
relation.tcx().mk_args_from_iter(iter::zip(a_arg.iter(), b_arg.iter()).map(|(a, b)| {
relation.cx().mk_args_from_iter(iter::zip(a_arg.iter(), b_arg.iter()).map(|(a, b)| {
relation.relate_with_variance(ty::Invariant, VarianceDiagInfo::default(), a, b)
}))
}
@ -141,14 +141,13 @@ pub fn relate_args_with_variances<I: Interner, R: TypeRelation<I>>(
b_arg: I::GenericArgs,
fetch_ty_for_diag: bool,
) -> RelateResult<I, I::GenericArgs> {
let tcx = relation.tcx();
let cx = relation.cx();
let mut cached_ty = None;
let params = iter::zip(a_arg.iter(), b_arg.iter()).enumerate().map(|(i, (a, b))| {
let variance = variances.get(i).unwrap();
let variance_info = if variance == ty::Invariant && fetch_ty_for_diag {
let ty =
*cached_ty.get_or_insert_with(|| tcx.type_of(ty_def_id).instantiate(tcx, a_arg));
let ty = *cached_ty.get_or_insert_with(|| cx.type_of(ty_def_id).instantiate(cx, a_arg));
VarianceDiagInfo::Invariant { ty, param_index: i.try_into().unwrap() }
} else {
VarianceDiagInfo::default()
@ -156,7 +155,7 @@ pub fn relate_args_with_variances<I: Interner, R: TypeRelation<I>>(
relation.relate_with_variance(variance, variance_info, a, b)
});
tcx.mk_args_from_iter(params)
cx.mk_args_from_iter(params)
}
impl<I: Interner> Relate<I> for ty::FnSig<I> {
@ -165,7 +164,7 @@ fn relate<R: TypeRelation<I>>(
a: ty::FnSig<I>,
b: ty::FnSig<I>,
) -> RelateResult<I, ty::FnSig<I>> {
let tcx = relation.tcx();
let cx = relation.cx();
if a.c_variadic != b.c_variadic {
return Err(TypeError::VariadicMismatch({
@ -210,7 +209,7 @@ fn relate<R: TypeRelation<I>>(
r => r,
});
Ok(ty::FnSig {
inputs_and_output: tcx.mk_type_list_from_iter(inputs_and_output)?,
inputs_and_output: cx.mk_type_list_from_iter(inputs_and_output)?,
c_variadic: a.c_variadic,
safety,
abi,
@ -245,11 +244,11 @@ fn relate<R: TypeRelation<I>>(
ExpectedFound::new(true, a, b)
}))
} else {
let args = match a.kind(relation.tcx()) {
let args = match a.kind(relation.cx()) {
ty::Opaque => relate_args_with_variances(
relation,
a.def_id,
relation.tcx().variances_of(a.def_id),
relation.cx().variances_of(a.def_id),
a.args,
b.args,
false, // do not fetch `type_of(a_def_id)`, as it will cause a cycle
@ -258,7 +257,7 @@ fn relate<R: TypeRelation<I>>(
relate_args_invariantly(relation, a.args, b.args)?
}
};
Ok(ty::AliasTy::new_from_args(relation.tcx(), a.def_id, args))
Ok(ty::AliasTy::new_from_args(relation.cx(), a.def_id, args))
}
}
}
@ -276,11 +275,11 @@ fn relate<R: TypeRelation<I>>(
ExpectedFound::new(true, a, b)
}))
} else {
let args = match a.kind(relation.tcx()) {
let args = match a.kind(relation.cx()) {
ty::AliasTermKind::OpaqueTy => relate_args_with_variances(
relation,
a.def_id,
relation.tcx().variances_of(a.def_id),
relation.cx().variances_of(a.def_id),
a.args,
b.args,
false, // do not fetch `type_of(a_def_id)`, as it will cause a cycle
@ -293,7 +292,7 @@ fn relate<R: TypeRelation<I>>(
relate_args_invariantly(relation, a.args, b.args)?
}
};
Ok(ty::AliasTerm::new_from_args(relation.tcx(), a.def_id, args))
Ok(ty::AliasTerm::new_from_args(relation.cx(), a.def_id, args))
}
}
}
@ -343,7 +342,7 @@ fn relate<R: TypeRelation<I>>(
}))
} else {
let args = relate_args_invariantly(relation, a.args, b.args)?;
Ok(ty::TraitRef::new_from_args(relation.tcx(), a.def_id, args))
Ok(ty::TraitRef::new_from_args(relation.cx(), a.def_id, args))
}
}
}
@ -377,7 +376,7 @@ pub fn structurally_relate_tys<I: Interner, R: TypeRelation<I>>(
a: I::Ty,
b: I::Ty,
) -> RelateResult<I, I::Ty> {
let tcx = relation.tcx();
let cx = relation.cx();
match (a.kind(), b.kind()) {
(ty::Infer(_), _) | (_, ty::Infer(_)) => {
// The caller should handle these cases!
@ -388,7 +387,7 @@ pub fn structurally_relate_tys<I: Interner, R: TypeRelation<I>>(
panic!("bound types encountered in structurally_relate_tys")
}
(ty::Error(guar), _) | (_, ty::Error(guar)) => Ok(Ty::new_error(tcx, guar)),
(ty::Error(guar), _) | (_, ty::Error(guar)) => Ok(Ty::new_error(cx, guar)),
(ty::Never, _)
| (ty::Char, _)
@ -412,16 +411,16 @@ pub fn structurally_relate_tys<I: Interner, R: TypeRelation<I>>(
(ty::Adt(a_def, a_args), ty::Adt(b_def, b_args)) if a_def == b_def => {
let args = relation.relate_item_args(a_def.def_id(), a_args, b_args)?;
Ok(Ty::new_adt(tcx, a_def, args))
Ok(Ty::new_adt(cx, a_def, args))
}
(ty::Foreign(a_id), ty::Foreign(b_id)) if a_id == b_id => Ok(Ty::new_foreign(tcx, a_id)),
(ty::Foreign(a_id), ty::Foreign(b_id)) if a_id == b_id => Ok(Ty::new_foreign(cx, a_id)),
(ty::Dynamic(a_obj, a_region, a_repr), ty::Dynamic(b_obj, b_region, b_repr))
if a_repr == b_repr =>
{
Ok(Ty::new_dynamic(
tcx,
cx,
relation.relate(a_obj, b_obj)?,
relation.relate(a_region, b_region)?,
a_repr,
@ -433,7 +432,7 @@ pub fn structurally_relate_tys<I: Interner, R: TypeRelation<I>>(
// the (anonymous) type of the same coroutine expression. So
// all of their regions should be equated.
let args = relate_args_invariantly(relation, a_args, b_args)?;
Ok(Ty::new_coroutine(tcx, a_id, args))
Ok(Ty::new_coroutine(cx, a_id, args))
}
(ty::CoroutineWitness(a_id, a_args), ty::CoroutineWitness(b_id, b_args))
@ -443,7 +442,7 @@ pub fn structurally_relate_tys<I: Interner, R: TypeRelation<I>>(
// the (anonymous) type of the same coroutine expression. So
// all of their regions should be equated.
let args = relate_args_invariantly(relation, a_args, b_args)?;
Ok(Ty::new_coroutine_witness(tcx, a_id, args))
Ok(Ty::new_coroutine_witness(cx, a_id, args))
}
(ty::Closure(a_id, a_args), ty::Closure(b_id, b_args)) if a_id == b_id => {
@ -451,14 +450,14 @@ pub fn structurally_relate_tys<I: Interner, R: TypeRelation<I>>(
// the (anonymous) type of the same closure expression. So
// all of their regions should be equated.
let args = relate_args_invariantly(relation, a_args, b_args)?;
Ok(Ty::new_closure(tcx, a_id, args))
Ok(Ty::new_closure(cx, a_id, args))
}
(ty::CoroutineClosure(a_id, a_args), ty::CoroutineClosure(b_id, b_args))
if a_id == b_id =>
{
let args = relate_args_invariantly(relation, a_args, b_args)?;
Ok(Ty::new_coroutine_closure(tcx, a_id, args))
Ok(Ty::new_coroutine_closure(cx, a_id, args))
}
(ty::RawPtr(a_ty, a_mutbl), ty::RawPtr(b_ty, b_mutbl)) => {
@ -475,7 +474,7 @@ pub fn structurally_relate_tys<I: Interner, R: TypeRelation<I>>(
let ty = relation.relate_with_variance(variance, info, a_ty, b_ty)?;
Ok(Ty::new_ptr(tcx, ty, a_mutbl))
Ok(Ty::new_ptr(cx, ty, a_mutbl))
}
(ty::Ref(a_r, a_ty, a_mutbl), ty::Ref(b_r, b_ty, b_mutbl)) => {
@ -493,18 +492,18 @@ pub fn structurally_relate_tys<I: Interner, R: TypeRelation<I>>(
let r = relation.relate(a_r, b_r)?;
let ty = relation.relate_with_variance(variance, info, a_ty, b_ty)?;
Ok(Ty::new_ref(tcx, r, ty, a_mutbl))
Ok(Ty::new_ref(cx, r, ty, a_mutbl))
}
(ty::Array(a_t, sz_a), ty::Array(b_t, sz_b)) => {
let t = relation.relate(a_t, b_t)?;
match relation.relate(sz_a, sz_b) {
Ok(sz) => Ok(Ty::new_array_with_const_len(tcx, t, sz)),
Ok(sz) => Ok(Ty::new_array_with_const_len(cx, t, sz)),
Err(err) => {
// Check whether the lengths are both concrete/known values,
// but are unequal, for better diagnostics.
let sz_a = sz_a.try_to_target_usize(tcx);
let sz_b = sz_b.try_to_target_usize(tcx);
let sz_a = sz_a.try_to_target_usize(cx);
let sz_b = sz_b.try_to_target_usize(cx);
match (sz_a, sz_b) {
(Some(sz_a_val), Some(sz_b_val)) if sz_a_val != sz_b_val => Err(
@ -518,13 +517,13 @@ pub fn structurally_relate_tys<I: Interner, R: TypeRelation<I>>(
(ty::Slice(a_t), ty::Slice(b_t)) => {
let t = relation.relate(a_t, b_t)?;
Ok(Ty::new_slice(tcx, t))
Ok(Ty::new_slice(cx, t))
}
(ty::Tuple(as_), ty::Tuple(bs)) => {
if as_.len() == bs.len() {
Ok(Ty::new_tup_from_iter(
tcx,
cx,
iter::zip(as_.iter(), bs.iter()).map(|(a, b)| relation.relate(a, b)),
)?)
} else if !(as_.is_empty() || bs.is_empty()) {
@ -536,25 +535,25 @@ pub fn structurally_relate_tys<I: Interner, R: TypeRelation<I>>(
(ty::FnDef(a_def_id, a_args), ty::FnDef(b_def_id, b_args)) if a_def_id == b_def_id => {
let args = relation.relate_item_args(a_def_id, a_args, b_args)?;
Ok(Ty::new_fn_def(tcx, a_def_id, args))
Ok(Ty::new_fn_def(cx, a_def_id, args))
}
(ty::FnPtr(a_fty), ty::FnPtr(b_fty)) => {
let fty = relation.relate(a_fty, b_fty)?;
Ok(Ty::new_fn_ptr(tcx, fty))
Ok(Ty::new_fn_ptr(cx, fty))
}
// Alias tend to mostly already be handled downstream due to normalization.
(ty::Alias(a_kind, a_data), ty::Alias(b_kind, b_data)) => {
let alias_ty = relation.relate(a_data, b_data)?;
assert_eq!(a_kind, b_kind);
Ok(Ty::new_alias(tcx, a_kind, alias_ty))
Ok(Ty::new_alias(cx, a_kind, alias_ty))
}
(ty::Pat(a_ty, a_pat), ty::Pat(b_ty, b_pat)) => {
let ty = relation.relate(a_ty, b_ty)?;
let pat = relation.relate(a_pat, b_pat)?;
Ok(Ty::new_pat(tcx, ty, pat))
Ok(Ty::new_pat(cx, ty, pat))
}
_ => Err(TypeError::Sorts(ExpectedFound::new(true, a, b))),
@ -573,11 +572,11 @@ pub fn structurally_relate_consts<I: Interner, R: TypeRelation<I>>(
mut b: I::Const,
) -> RelateResult<I, I::Const> {
debug!("{}.structurally_relate_consts(a = {:?}, b = {:?})", relation.tag(), a, b);
let tcx = relation.tcx();
let cx = relation.cx();
if tcx.features().generic_const_exprs() {
a = tcx.expand_abstract_consts(a);
b = tcx.expand_abstract_consts(b);
if cx.features().generic_const_exprs() {
a = cx.expand_abstract_consts(a);
b = cx.expand_abstract_consts(b);
}
debug!("{}.structurally_relate_consts(normed_a = {:?}, normed_b = {:?})", relation.tag(), a, b);
@ -607,8 +606,8 @@ pub fn structurally_relate_consts<I: Interner, R: TypeRelation<I>>(
// be stabilized.
(ty::ConstKind::Unevaluated(au), ty::ConstKind::Unevaluated(bu)) if au.def == bu.def => {
if cfg!(debug_assertions) {
let a_ty = tcx.type_of(au.def).instantiate(tcx, au.args);
let b_ty = tcx.type_of(bu.def).instantiate(tcx, bu.args);
let a_ty = cx.type_of(au.def).instantiate(cx, au.args);
let b_ty = cx.type_of(bu.def).instantiate(cx, bu.args);
assert_eq!(a_ty, b_ty);
}
@ -618,11 +617,11 @@ pub fn structurally_relate_consts<I: Interner, R: TypeRelation<I>>(
au.args,
bu.args,
)?;
return Ok(Const::new_unevaluated(tcx, ty::UnevaluatedConst { def: au.def, args }));
return Ok(Const::new_unevaluated(cx, ty::UnevaluatedConst { def: au.def, args }));
}
(ty::ConstKind::Expr(ae), ty::ConstKind::Expr(be)) => {
let expr = relation.relate(ae, be)?;
return Ok(Const::new_expr(tcx, expr));
return Ok(Const::new_expr(cx, expr));
}
_ => false,
};

8
compiler/rustc_type_ir/src/solve/mod.rs
View File

@ -106,13 +106,13 @@ pub struct Goal<I: Interner, P> {
}
impl<I: Interner, P> Goal<I, P> {
pub fn new(tcx: I, param_env: I::ParamEnv, predicate: impl Upcast<I, P>) -> Goal<I, P> {
Goal { param_env, predicate: predicate.upcast(tcx) }
pub fn new(cx: I, param_env: I::ParamEnv, predicate: impl Upcast<I, P>) -> Goal<I, P> {
Goal { param_env, predicate: predicate.upcast(cx) }
}
/// Updates the goal to one with a different `predicate` but the same `param_env`.
pub fn with<Q>(self, tcx: I, predicate: impl Upcast<I, Q>) -> Goal<I, Q> {
Goal { param_env: self.param_env, predicate: predicate.upcast(tcx) }
pub fn with<Q>(self, cx: I, predicate: impl Upcast<I, Q>) -> Goal<I, Q> {
Goal { param_env: self.param_env, predicate: predicate.upcast(cx) }
}
}

34
compiler/rustc_type_ir/src/ty_kind/closure.rs
View File

@ -136,9 +136,9 @@ pub struct ClosureArgsParts<I: Interner> {
impl<I: Interner> ClosureArgs<I> {
/// Construct `ClosureArgs` from `ClosureArgsParts`, containing `Args`
/// for the closure parent, alongside additional closure-specific components.
pub fn new(tcx: I, parts: ClosureArgsParts<I>) -> ClosureArgs<I> {
pub fn new(cx: I, parts: ClosureArgsParts<I>) -> ClosureArgs<I> {
ClosureArgs {
args: tcx.mk_args_from_iter(parts.parent_args.iter().chain([
args: cx.mk_args_from_iter(parts.parent_args.iter().chain([
parts.closure_kind_ty.into(),
parts.closure_sig_as_fn_ptr_ty.into(),
parts.tupled_upvars_ty.into(),
@ -258,9 +258,9 @@ pub struct CoroutineClosureArgsParts<I: Interner> {
}
impl<I: Interner> CoroutineClosureArgs<I> {
pub fn new(tcx: I, parts: CoroutineClosureArgsParts<I>) -> CoroutineClosureArgs<I> {
pub fn new(cx: I, parts: CoroutineClosureArgsParts<I>) -> CoroutineClosureArgs<I> {
CoroutineClosureArgs {
args: tcx.mk_args_from_iter(parts.parent_args.iter().chain([
args: cx.mk_args_from_iter(parts.parent_args.iter().chain([
parts.closure_kind_ty.into(),
parts.signature_parts_ty.into(),
parts.tupled_upvars_ty.into(),
@ -409,14 +409,14 @@ impl<I: Interner> CoroutineClosureSignature<I> {
/// When the kind and upvars are known, use the other helper functions.
pub fn to_coroutine(
self,
tcx: I,
cx: I,
parent_args: I::GenericArgsSlice,
coroutine_kind_ty: I::Ty,
coroutine_def_id: I::DefId,
tupled_upvars_ty: I::Ty,
) -> I::Ty {
let coroutine_args = ty::CoroutineArgs::new(
tcx,
cx,
ty::CoroutineArgsParts {
parent_args,
kind_ty: coroutine_kind_ty,
@ -428,7 +428,7 @@ pub fn to_coroutine(
},
);
Ty::new_coroutine(tcx, coroutine_def_id, coroutine_args.args)
Ty::new_coroutine(cx, coroutine_def_id, coroutine_args.args)
}
/// Given known upvars and a [`ClosureKind`](ty::ClosureKind), compute the coroutine
@ -438,7 +438,7 @@ pub fn to_coroutine(
/// that the `ClosureKind` is actually supported by the coroutine-closure.
pub fn to_coroutine_given_kind_and_upvars(
self,
tcx: I,
cx: I,
parent_args: I::GenericArgsSlice,
coroutine_def_id: I::DefId,
goal_kind: ty::ClosureKind,
@ -447,7 +447,7 @@ pub fn to_coroutine_given_kind_and_upvars(
coroutine_captures_by_ref_ty: I::Ty,
) -> I::Ty {
let tupled_upvars_ty = Self::tupled_upvars_by_closure_kind(
tcx,
cx,
goal_kind,
self.tupled_inputs_ty,
closure_tupled_upvars_ty,
@ -456,9 +456,9 @@ pub fn to_coroutine_given_kind_and_upvars(
);
self.to_coroutine(
tcx,
cx,
parent_args,
Ty::from_coroutine_closure_kind(tcx, goal_kind),
Ty::from_coroutine_closure_kind(cx, goal_kind),
coroutine_def_id,
tupled_upvars_ty,
)
@ -474,7 +474,7 @@ pub fn to_coroutine_given_kind_and_upvars(
/// lifetimes are related to the lifetime of the borrow on the closure made for
/// the call. This allows borrowck to enforce the self-borrows correctly.
pub fn tupled_upvars_by_closure_kind(
tcx: I,
cx: I,
kind: ty::ClosureKind,
tupled_inputs_ty: I::Ty,
closure_tupled_upvars_ty: I::Ty,
@ -488,12 +488,12 @@ pub fn tupled_upvars_by_closure_kind(
};
let coroutine_captures_by_ref_ty =
sig.output().skip_binder().fold_with(&mut FoldEscapingRegions {
interner: tcx,
interner: cx,
region: env_region,
debruijn: ty::INNERMOST,
});
Ty::new_tup_from_iter(
tcx,
cx,
tupled_inputs_ty
.tuple_fields()
.iter()
@ -501,7 +501,7 @@ pub fn tupled_upvars_by_closure_kind(
)
}
ty::ClosureKind::FnOnce => Ty::new_tup_from_iter(
tcx,
cx,
tupled_inputs_ty
.tuple_fields()
.iter()
@ -615,9 +615,9 @@ pub struct CoroutineArgsParts<I: Interner> {
impl<I: Interner> CoroutineArgs<I> {
/// Construct `CoroutineArgs` from `CoroutineArgsParts`, containing `Args`
/// for the coroutine parent, alongside additional coroutine-specific components.
pub fn new(tcx: I, parts: CoroutineArgsParts<I>) -> CoroutineArgs<I> {
pub fn new(cx: I, parts: CoroutineArgsParts<I>) -> CoroutineArgs<I> {
CoroutineArgs {
args: tcx.mk_args_from_iter(parts.parent_args.iter().chain([
args: cx.mk_args_from_iter(parts.parent_args.iter().chain([
parts.kind_ty.into(),
parts.resume_ty.into(),
parts.yield_ty.into(),