Overhaul PredicateInner
and Predicate
.
Specifically, change `Ty` from this: ``` pub struct Predicate<'tcx> { inner: &'tcx PredicateInner<'tcx> } ``` to this: ``` pub struct Predicate<'tcx>(&'tcx Interned<PredicateS<'tcx>>) ``` where `PredicateInner` is renamed as `PredicateS`. This (plus a few other minor changes) makes the parallels with `Ty` and `TyS` much clearer, and makes the uniqueness more explicit.
This commit is contained in:
parent
e9a0c429c5
commit
925ec0d3c7
8 changed files with 68 additions and 69 deletions
|
@ -88,7 +88,7 @@ macro_rules! arena_types {
|
|||
|
||||
// Interned types
|
||||
[] tys: rustc_middle::ty::TyS<'tcx>,
|
||||
[] predicates: rustc_middle::ty::PredicateInner<'tcx>,
|
||||
[] predicates: rustc_middle::ty::PredicateS<'tcx>,
|
||||
|
||||
// Note that this deliberately duplicates items in the `rustc_hir::arena`,
|
||||
// since we need to allocate this type on both the `rustc_hir` arena
|
||||
|
|
|
@ -20,7 +20,7 @@ use crate::ty::{
|
|||
self, AdtDef, AdtKind, Binder, BindingMode, BoundVar, CanonicalPolyFnSig,
|
||||
ClosureSizeProfileData, Const, ConstVid, DefIdTree, ExistentialPredicate, FloatTy, FloatVar,
|
||||
FloatVid, GenericParamDefKind, InferConst, InferTy, IntTy, IntVar, IntVid, List, ParamConst,
|
||||
ParamTy, PolyFnSig, Predicate, PredicateInner, PredicateKind, ProjectionTy, Region, RegionKind,
|
||||
ParamTy, PolyFnSig, Predicate, PredicateKind, PredicateS, ProjectionTy, Region, RegionKind,
|
||||
ReprOptions, TraitObjectVisitor, Ty, TyKind, TyS, TyVar, TyVid, TypeAndMut, UintTy,
|
||||
};
|
||||
use rustc_ast as ast;
|
||||
|
@ -107,7 +107,7 @@ pub struct CtxtInterners<'tcx> {
|
|||
region: InternedSet<'tcx, RegionKind>,
|
||||
poly_existential_predicates:
|
||||
InternedSet<'tcx, List<ty::Binder<'tcx, ExistentialPredicate<'tcx>>>>,
|
||||
predicate: InternedSet<'tcx, PredicateInner<'tcx>>,
|
||||
predicate: InternedSet<'tcx, PredicateS<'tcx>>,
|
||||
predicates: InternedSet<'tcx, List<Predicate<'tcx>>>,
|
||||
projs: InternedSet<'tcx, List<ProjectionKind>>,
|
||||
place_elems: InternedSet<'tcx, List<PlaceElem<'tcx>>>,
|
||||
|
@ -170,23 +170,22 @@ impl<'tcx> CtxtInterners<'tcx> {
|
|||
}
|
||||
|
||||
#[inline(never)]
|
||||
fn intern_predicate(
|
||||
&self,
|
||||
kind: Binder<'tcx, PredicateKind<'tcx>>,
|
||||
) -> &'tcx PredicateInner<'tcx> {
|
||||
self.predicate
|
||||
.intern(kind, |kind| {
|
||||
let flags = super::flags::FlagComputation::for_predicate(kind);
|
||||
fn intern_predicate(&self, kind: Binder<'tcx, PredicateKind<'tcx>>) -> Predicate<'tcx> {
|
||||
Predicate(Interned::new_unchecked(
|
||||
self.predicate
|
||||
.intern(kind, |kind| {
|
||||
let flags = super::flags::FlagComputation::for_predicate(kind);
|
||||
|
||||
let predicate_struct = PredicateInner {
|
||||
kind,
|
||||
flags: flags.flags,
|
||||
outer_exclusive_binder: flags.outer_exclusive_binder,
|
||||
};
|
||||
let predicate_struct = PredicateS {
|
||||
kind,
|
||||
flags: flags.flags,
|
||||
outer_exclusive_binder: flags.outer_exclusive_binder,
|
||||
};
|
||||
|
||||
InternedInSet(self.arena.alloc(predicate_struct))
|
||||
})
|
||||
.0
|
||||
InternedInSet(self.arena.alloc(predicate_struct))
|
||||
})
|
||||
.0,
|
||||
))
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1684,7 +1683,7 @@ nop_lift! {type_; Ty<'a> => Ty<'tcx>}
|
|||
nop_lift_old! {region; Region<'a> => Region<'tcx>}
|
||||
nop_lift_old! {const_; &'a Const<'a> => &'tcx Const<'tcx>}
|
||||
nop_lift_old! {const_allocation; &'a Allocation => &'tcx Allocation}
|
||||
nop_lift_old! {predicate; &'a PredicateInner<'a> => &'tcx PredicateInner<'tcx>}
|
||||
nop_lift! {predicate; Predicate<'a> => Predicate<'tcx>}
|
||||
|
||||
nop_list_lift! {type_list; Ty<'a> => Ty<'tcx>}
|
||||
nop_list_lift! {poly_existential_predicates; ty::Binder<'a, ExistentialPredicate<'a>> => ty::Binder<'tcx, ExistentialPredicate<'tcx>>}
|
||||
|
@ -2040,23 +2039,23 @@ impl<'tcx> Hash for InternedInSet<'tcx, TyS<'tcx>> {
|
|||
}
|
||||
}
|
||||
|
||||
impl<'tcx> Borrow<Binder<'tcx, PredicateKind<'tcx>>> for InternedInSet<'tcx, PredicateInner<'tcx>> {
|
||||
impl<'tcx> Borrow<Binder<'tcx, PredicateKind<'tcx>>> for InternedInSet<'tcx, PredicateS<'tcx>> {
|
||||
fn borrow<'a>(&'a self) -> &'a Binder<'tcx, PredicateKind<'tcx>> {
|
||||
&self.0.kind
|
||||
}
|
||||
}
|
||||
|
||||
impl<'tcx> PartialEq for InternedInSet<'tcx, PredicateInner<'tcx>> {
|
||||
fn eq(&self, other: &InternedInSet<'tcx, PredicateInner<'tcx>>) -> bool {
|
||||
impl<'tcx> PartialEq for InternedInSet<'tcx, PredicateS<'tcx>> {
|
||||
fn eq(&self, other: &InternedInSet<'tcx, PredicateS<'tcx>>) -> bool {
|
||||
// The `Borrow` trait requires that `x.borrow() == y.borrow()` equals
|
||||
// `x == y`.
|
||||
self.0.kind == other.0.kind
|
||||
}
|
||||
}
|
||||
|
||||
impl<'tcx> Eq for InternedInSet<'tcx, PredicateInner<'tcx>> {}
|
||||
impl<'tcx> Eq for InternedInSet<'tcx, PredicateS<'tcx>> {}
|
||||
|
||||
impl<'tcx> Hash for InternedInSet<'tcx, PredicateInner<'tcx>> {
|
||||
impl<'tcx> Hash for InternedInSet<'tcx, PredicateS<'tcx>> {
|
||||
fn hash<H: Hasher>(&self, s: &mut H) {
|
||||
// The `Borrow` trait requires that `x.borrow().hash(s) == x.hash(s)`.
|
||||
self.0.kind.hash(s)
|
||||
|
@ -2237,8 +2236,7 @@ impl<'tcx> TyCtxt<'tcx> {
|
|||
|
||||
#[inline]
|
||||
pub fn mk_predicate(self, binder: Binder<'tcx, PredicateKind<'tcx>>) -> Predicate<'tcx> {
|
||||
let inner = self.interners.intern_predicate(binder);
|
||||
Predicate { inner }
|
||||
self.interners.intern_predicate(binder)
|
||||
}
|
||||
|
||||
#[inline]
|
||||
|
|
|
@ -1181,7 +1181,7 @@ impl<'tcx> TypeVisitor<'tcx> for HasEscapingVarsVisitor {
|
|||
|
||||
#[inline]
|
||||
fn visit_predicate(&mut self, predicate: ty::Predicate<'tcx>) -> ControlFlow<Self::BreakTy> {
|
||||
if predicate.inner.outer_exclusive_binder > self.outer_index {
|
||||
if predicate.outer_exclusive_binder() > self.outer_index {
|
||||
ControlFlow::Break(FoundEscapingVars)
|
||||
} else {
|
||||
ControlFlow::CONTINUE
|
||||
|
@ -1263,9 +1263,11 @@ impl<'tcx> TypeVisitor<'tcx> for HasTypeFlagsVisitor {
|
|||
fn visit_predicate(&mut self, predicate: ty::Predicate<'tcx>) -> ControlFlow<Self::BreakTy> {
|
||||
debug!(
|
||||
"HasTypeFlagsVisitor: predicate={:?} predicate.flags={:?} self.flags={:?}",
|
||||
predicate, predicate.inner.flags, self.flags
|
||||
predicate,
|
||||
predicate.flags(),
|
||||
self.flags
|
||||
);
|
||||
if predicate.inner.flags.intersects(self.flags) {
|
||||
if predicate.flags().intersects(self.flags) {
|
||||
ControlFlow::Break(FoundFlags)
|
||||
} else {
|
||||
ControlFlow::CONTINUE
|
||||
|
|
|
@ -43,9 +43,9 @@ use rustc_span::symbol::{kw, Ident, Symbol};
|
|||
use rustc_span::{sym, Span};
|
||||
use rustc_target::abi::Align;
|
||||
|
||||
use std::hash::{Hash, Hasher};
|
||||
use std::hash::Hash;
|
||||
use std::ops::ControlFlow;
|
||||
use std::{fmt, ptr, str};
|
||||
use std::{fmt, str};
|
||||
|
||||
pub use crate::ty::diagnostics::*;
|
||||
pub use rustc_type_ir::InferTy::*;
|
||||
|
@ -466,51 +466,50 @@ impl ty::EarlyBoundRegion {
|
|||
}
|
||||
}
|
||||
|
||||
/// Represents a predicate.
|
||||
///
|
||||
/// See comments on `TyS`, which apply here too (albeit for
|
||||
/// `PredicateS`/`Predicate` rather than `TyS`/`Ty`).
|
||||
#[derive(Debug)]
|
||||
crate struct PredicateInner<'tcx> {
|
||||
crate struct PredicateS<'tcx> {
|
||||
kind: Binder<'tcx, PredicateKind<'tcx>>,
|
||||
flags: TypeFlags,
|
||||
/// See the comment for the corresponding field of [TyS].
|
||||
outer_exclusive_binder: ty::DebruijnIndex,
|
||||
}
|
||||
|
||||
// This type is used a lot. Make sure it doesn't unintentionally get bigger.
|
||||
#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
|
||||
static_assert_size!(PredicateInner<'_>, 56);
|
||||
static_assert_size!(PredicateS<'_>, 56);
|
||||
|
||||
#[derive(Clone, Copy, Lift)]
|
||||
pub struct Predicate<'tcx> {
|
||||
inner: &'tcx PredicateInner<'tcx>,
|
||||
}
|
||||
|
||||
impl<'tcx> PartialEq for Predicate<'tcx> {
|
||||
fn eq(&self, other: &Self) -> bool {
|
||||
// `self.kind` is always interned.
|
||||
ptr::eq(self.inner, other.inner)
|
||||
}
|
||||
}
|
||||
|
||||
impl Hash for Predicate<'_> {
|
||||
fn hash<H: Hasher>(&self, s: &mut H) {
|
||||
(self.inner as *const PredicateInner<'_>).hash(s)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'tcx> Eq for Predicate<'tcx> {}
|
||||
/// Use this rather than `PredicateS`, whenever possible.
|
||||
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
|
||||
#[cfg_attr(not(bootstrap), rustc_pass_by_value)]
|
||||
pub struct Predicate<'tcx>(Interned<'tcx, PredicateS<'tcx>>);
|
||||
|
||||
impl<'tcx> Predicate<'tcx> {
|
||||
/// Gets the inner `Binder<'tcx, PredicateKind<'tcx>>`.
|
||||
#[inline]
|
||||
pub fn kind(self) -> Binder<'tcx, PredicateKind<'tcx>> {
|
||||
self.inner.kind
|
||||
self.0.kind
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pub fn flags(self) -> TypeFlags {
|
||||
self.0.flags
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
pub fn outer_exclusive_binder(self) -> DebruijnIndex {
|
||||
self.0.outer_exclusive_binder
|
||||
}
|
||||
|
||||
/// Flips the polarity of a Predicate.
|
||||
///
|
||||
/// Given `T: Trait` predicate it returns `T: !Trait` and given `T: !Trait` returns `T: Trait`.
|
||||
pub fn flip_polarity(&self, tcx: TyCtxt<'tcx>) -> Option<Predicate<'tcx>> {
|
||||
pub fn flip_polarity(self, tcx: TyCtxt<'tcx>) -> Option<Predicate<'tcx>> {
|
||||
let kind = self
|
||||
.inner
|
||||
.kind
|
||||
.kind()
|
||||
.map_bound(|kind| match kind {
|
||||
PredicateKind::Trait(TraitPredicate { trait_ref, constness, polarity }) => {
|
||||
Some(PredicateKind::Trait(TraitPredicate {
|
||||
|
@ -530,14 +529,14 @@ impl<'tcx> Predicate<'tcx> {
|
|||
|
||||
impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for Predicate<'tcx> {
|
||||
fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
|
||||
let PredicateInner {
|
||||
let PredicateS {
|
||||
ref kind,
|
||||
|
||||
// The other fields just provide fast access to information that is
|
||||
// also contained in `kind`, so no need to hash them.
|
||||
flags: _,
|
||||
outer_exclusive_binder: _,
|
||||
} = self.inner;
|
||||
} = self.0.0;
|
||||
|
||||
kind.hash_stable(hcx, hasher);
|
||||
}
|
||||
|
|
|
@ -1112,12 +1112,12 @@ impl<'tcx> TypeFoldable<'tcx> for ty::Predicate<'tcx> {
|
|||
self,
|
||||
folder: &mut F,
|
||||
) -> Result<Self, F::Error> {
|
||||
let new = self.inner.kind.try_fold_with(folder)?;
|
||||
let new = self.kind().try_fold_with(folder)?;
|
||||
Ok(folder.tcx().reuse_or_mk_predicate(self, new))
|
||||
}
|
||||
|
||||
fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> ControlFlow<V::BreakTy> {
|
||||
self.inner.kind.visit_with(visitor)
|
||||
self.kind().visit_with(visitor)
|
||||
}
|
||||
|
||||
fn visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> ControlFlow<V::BreakTy> {
|
||||
|
@ -1125,11 +1125,11 @@ impl<'tcx> TypeFoldable<'tcx> for ty::Predicate<'tcx> {
|
|||
}
|
||||
|
||||
fn has_vars_bound_at_or_above(&self, binder: ty::DebruijnIndex) -> bool {
|
||||
self.inner.outer_exclusive_binder > binder
|
||||
self.outer_exclusive_binder() > binder
|
||||
}
|
||||
|
||||
fn has_type_flags(&self, flags: ty::TypeFlags) -> bool {
|
||||
self.inner.flags.intersects(flags)
|
||||
self.flags().intersects(flags)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue