Some renaming nits for rustc_type_ir

compiler/rustc_middle/src/ty/context.rs

@@ -80,42 +80,40 @@ use std::ops::{Bound, Deref};
 
 #[allow(rustc::usage_of_ty_tykind)]
 impl<'tcx> Interner for TyCtxt<'tcx> {
+    type DefId = DefId;
     type AdtDef = ty::AdtDef<'tcx>;
-    type GenericArgsRef = ty::GenericArgsRef<'tcx>;
+    type GenericArgs = ty::GenericArgsRef<'tcx>;
     type GenericArg = ty::GenericArg<'tcx>;
-    type DefId = DefId;
     type Binder<T> = Binder<'tcx, T>;
-    type Ty = Ty<'tcx>;
-    type Const = ty::Const<'tcx>;
-    type Region = Region<'tcx>;
     type Predicate = Predicate<'tcx>;
+    type PredicateKind = ty::PredicateKind<'tcx>;
     type TypeAndMut = TypeAndMut<'tcx>;
     type Mutability = hir::Mutability;
     type Movability = hir::Movability;
-    type PolyFnSig = PolyFnSig<'tcx>;
-    type ListBinderExistentialPredicate = &'tcx List<PolyExistentialPredicate<'tcx>>;
-    type ListTy = &'tcx List<Ty<'tcx>>;
+    type Ty = Ty<'tcx>;
+    type Tys = &'tcx List<Ty<'tcx>>;
     type AliasTy = ty::AliasTy<'tcx>;
     type ParamTy = ParamTy;
     type BoundTy = ty::BoundTy;
-    type PlaceholderType = ty::PlaceholderType;
+    type PlaceholderTy = ty::PlaceholderType;
     type InferTy = InferTy;
     type ErrorGuaranteed = ErrorGuaranteed;
-    type PredicateKind = ty::PredicateKind<'tcx>;
+    type BoundExistentialPredicates = &'tcx List<PolyExistentialPredicate<'tcx>>;
+    type PolyFnSig = PolyFnSig<'tcx>;
     type AllocId = crate::mir::interpret::AllocId;
-
+    type Const = ty::Const<'tcx>;
     type InferConst = ty::InferConst<'tcx>;
     type AliasConst = ty::UnevaluatedConst<'tcx>;
+    type PlaceholderConst = ty::PlaceholderConst<'tcx>;
     type ParamConst = ty::ParamConst;
     type BoundConst = ty::BoundVar;
-    type PlaceholderConst = ty::PlaceholderConst<'tcx>;
     type ValueConst = ty::ValTree<'tcx>;
     type ExprConst = ty::Expr<'tcx>;
-
+    type Region = Region<'tcx>;
     type EarlyBoundRegion = ty::EarlyBoundRegion;
     type BoundRegion = ty::BoundRegion;
     type FreeRegion = ty::FreeRegion;
-    type RegionVid = ty::RegionVid;
+    type InferRegion = ty::RegionVid;
     type PlaceholderRegion = ty::PlaceholderRegion;
 
     fn ty_and_mut_to_parts(

compiler/rustc_type_ir/src/lib.rs

@@ -42,34 +42,43 @@ pub use ty_info::*;
 pub trait HashStableContext {}
 
 pub trait Interner: Sized {
+    type DefId: Clone + Debug + Hash + Ord;
     type AdtDef: Clone + Debug + Hash + Ord;
-    type GenericArgsRef: Clone
+
+    type GenericArgs: Clone
         + DebugWithInfcx<Self>
         + Hash
         + Ord
         + IntoIterator<Item = Self::GenericArg>;
     type GenericArg: Clone + DebugWithInfcx<Self> + Hash + Ord;
-    type DefId: Clone + Debug + Hash + Ord;
+
     type Binder<T>;
-    type Ty: Clone + DebugWithInfcx<Self> + Hash + Ord;
-    type Const: Clone + DebugWithInfcx<Self> + Hash + Ord;
-    type Region: Clone + DebugWithInfcx<Self> + Hash + Ord;
+
+    // Predicates
     type Predicate;
+    type PredicateKind: Clone + Debug + Hash + PartialEq + Eq;
+
     type TypeAndMut: Clone + Debug + Hash + Ord;
     type Mutability: Clone + Debug + Hash + Ord;
     type Movability: Clone + Debug + Hash + Ord;
-    type PolyFnSig: Clone + DebugWithInfcx<Self> + Hash + Ord;
-    type ListBinderExistentialPredicate: Clone + DebugWithInfcx<Self> + Hash + Ord;
-    type ListTy: Clone + Debug + Hash + Ord + IntoIterator<Item = Self::Ty>;
+
+    // Kinds of tys
+    type Ty: Clone + DebugWithInfcx<Self> + Hash + Ord;
+    type Tys: Clone + Debug + Hash + Ord + IntoIterator<Item = Self::Ty>;
     type AliasTy: Clone + DebugWithInfcx<Self> + Hash + Ord;
     type ParamTy: Clone + Debug + Hash + Ord;
     type BoundTy: Clone + Debug + Hash + Ord;
-    type PlaceholderType: Clone + Debug + Hash + Ord;
+    type PlaceholderTy: Clone + Debug + Hash + Ord;
     type InferTy: Clone + DebugWithInfcx<Self> + Hash + Ord;
+
+    // Things stored inside of tys
     type ErrorGuaranteed: Clone + Debug + Hash + Ord;
-    type PredicateKind: Clone + Debug + Hash + PartialEq + Eq;
+    type BoundExistentialPredicates: Clone + DebugWithInfcx<Self> + Hash + Ord;
+    type PolyFnSig: Clone + DebugWithInfcx<Self> + Hash + Ord;
     type AllocId: Clone + Debug + Hash + Ord;
 
+    // Kinds of consts
+    type Const: Clone + DebugWithInfcx<Self> + Hash + Ord;
     type InferConst: Clone + DebugWithInfcx<Self> + Hash + Ord;
     type AliasConst: Clone + DebugWithInfcx<Self> + Hash + Ord;
     type PlaceholderConst: Clone + Debug + Hash + Ord;
@@ -78,10 +87,12 @@ pub trait Interner: Sized {
     type ValueConst: Clone + Debug + Hash + Ord;
     type ExprConst: Clone + DebugWithInfcx<Self> + Hash + Ord;
 
+    // Kinds of regions
+    type Region: Clone + DebugWithInfcx<Self> + Hash + Ord;
     type EarlyBoundRegion: Clone + Debug + Hash + Ord;
     type BoundRegion: Clone + Debug + Hash + Ord;
     type FreeRegion: Clone + Debug + Hash + Ord;
-    type RegionVid: Clone + DebugWithInfcx<Self> + Hash + Ord;
+    type InferRegion: Clone + DebugWithInfcx<Self> + Hash + Ord;
     type PlaceholderRegion: Clone + Debug + Hash + Ord;
 
     fn ty_and_mut_to_parts(ty_and_mut: Self::TypeAndMut) -> (Self::Ty, Self::Mutability);

compiler/rustc_type_ir/src/structural_impls.rs

@@ -208,7 +208,7 @@ impl<I: Interner, T: TypeVisitable<I>, Ix: Idx> TypeVisitable<I> for IndexVec<Ix
 
 pub trait InferCtxtLike<I: Interner> {
     fn universe_of_ty(&self, ty: I::InferTy) -> Option<UniverseIndex>;
-    fn universe_of_lt(&self, lt: I::RegionVid) -> Option<UniverseIndex>;
+    fn universe_of_lt(&self, lt: I::InferRegion) -> Option<UniverseIndex>;
     fn universe_of_ct(&self, ct: I::InferConst) -> Option<UniverseIndex>;
 }
 
@@ -219,7 +219,7 @@ impl<I: Interner> InferCtxtLike<I> for core::convert::Infallible {
     fn universe_of_ct(&self, _ct: <I as Interner>::InferConst) -> Option<UniverseIndex> {
         match *self {}
     }
-    fn universe_of_lt(&self, _lt: <I as Interner>::RegionVid) -> Option<UniverseIndex> {
+    fn universe_of_lt(&self, _lt: <I as Interner>::InferRegion) -> Option<UniverseIndex> {
         match *self {}
     }
 }

compiler/rustc_type_ir/src/sty.rs

@@ -79,7 +79,7 @@ pub enum TyKind<I: Interner> {
     ///
     /// Note that generic parameters in fields only get lazily substituted
     /// by using something like `adt_def.all_fields().map(|field| field.ty(tcx, args))`.
-    Adt(I::AdtDef, I::GenericArgsRef),
+    Adt(I::AdtDef, I::GenericArgs),
 
     /// An unsized FFI type that is opaque to Rust. Written as `extern type T`.
     Foreign(I::DefId),
@@ -111,7 +111,7 @@ pub enum TyKind<I: Interner> {
     /// fn foo() -> i32 { 1 }
     /// let bar = foo; // bar: fn() -> i32 {foo}
     /// ```
-    FnDef(I::DefId, I::GenericArgsRef),
+    FnDef(I::DefId, I::GenericArgs),
 
     /// A pointer to a function. Written as `fn() -> i32`.
     ///
@@ -127,21 +127,21 @@ pub enum TyKind<I: Interner> {
     FnPtr(I::PolyFnSig),
 
     /// A trait object. Written as `dyn for<'b> Trait<'b, Assoc = u32> + Send + 'a`.
-    Dynamic(I::ListBinderExistentialPredicate, I::Region, DynKind),
+    Dynamic(I::BoundExistentialPredicates, I::Region, DynKind),
 
     /// The anonymous type of a closure. Used to represent the type of `|a| a`.
     ///
     /// Closure args contain both the - potentially substituted - generic parameters
     /// of its parent and some synthetic parameters. See the documentation for
     /// `ClosureArgs` for more details.
-    Closure(I::DefId, I::GenericArgsRef),
+    Closure(I::DefId, I::GenericArgs),
 
     /// The anonymous type of a generator. Used to represent the type of
     /// `|a| yield a`.
     ///
     /// For more info about generator args, visit the documentation for
     /// `GeneratorArgs`.
-    Generator(I::DefId, I::GenericArgsRef, I::Movability),
+    Generator(I::DefId, I::GenericArgs, I::Movability),
 
     /// A type representing the types stored inside a generator.
     /// This should only appear as part of the `GeneratorArgs`.
@@ -167,13 +167,13 @@ pub enum TyKind<I: Interner> {
     /// }
     /// # ;
     /// ```
-    GeneratorWitness(I::DefId, I::GenericArgsRef),
+    GeneratorWitness(I::DefId, I::GenericArgs),
 
     /// The never type `!`.
     Never,
 
     /// A tuple type. For example, `(i32, bool)`.
-    Tuple(I::ListTy),
+    Tuple(I::Tys),
 
     /// A projection, opaque type, weak type alias, or inherent associated type.
     /// All of these types are represented as pairs of def-id and args, and can
@@ -209,7 +209,7 @@ pub enum TyKind<I: Interner> {
     /// to the bound variable's index from the binder from which it was instantiated),
     /// and `U` is the universe index in which it is instantiated, or totally omitted
     /// if the universe index is zero.
-    Placeholder(I::PlaceholderType),
+    Placeholder(I::PlaceholderTy),
 
     /// A type variable used during type checking.
     ///
@@ -567,7 +567,7 @@ impl<I: Interner, E: TyEncoder> Encodable<E> for TyKind<I>
 where
     I::ErrorGuaranteed: Encodable<E>,
     I::AdtDef: Encodable<E>,
-    I::GenericArgsRef: Encodable<E>,
+    I::GenericArgs: Encodable<E>,
     I::DefId: Encodable<E>,
     I::Ty: Encodable<E>,
     I::Const: Encodable<E>,
@@ -576,12 +576,12 @@ where
     I::Mutability: Encodable<E>,
     I::Movability: Encodable<E>,
     I::PolyFnSig: Encodable<E>,
-    I::ListBinderExistentialPredicate: Encodable<E>,
-    I::ListTy: Encodable<E>,
+    I::BoundExistentialPredicates: Encodable<E>,
+    I::Tys: Encodable<E>,
     I::AliasTy: Encodable<E>,
     I::ParamTy: Encodable<E>,
     I::BoundTy: Encodable<E>,
-    I::PlaceholderType: Encodable<E>,
+    I::PlaceholderTy: Encodable<E>,
     I::InferTy: Encodable<E>,
     I::PredicateKind: Encodable<E>,
     I::AllocId: Encodable<E>,
@@ -681,7 +681,7 @@ impl<I: Interner, D: TyDecoder<I = I>> Decodable<D> for TyKind<I>
 where
     I::ErrorGuaranteed: Decodable<D>,
     I::AdtDef: Decodable<D>,
-    I::GenericArgsRef: Decodable<D>,
+    I::GenericArgs: Decodable<D>,
     I::DefId: Decodable<D>,
     I::Ty: Decodable<D>,
     I::Const: Decodable<D>,
@@ -690,13 +690,13 @@ where
     I::Mutability: Decodable<D>,
     I::Movability: Decodable<D>,
     I::PolyFnSig: Decodable<D>,
-    I::ListBinderExistentialPredicate: Decodable<D>,
-    I::ListTy: Decodable<D>,
+    I::BoundExistentialPredicates: Decodable<D>,
+    I::Tys: Decodable<D>,
     I::AliasTy: Decodable<D>,
     I::ParamTy: Decodable<D>,
     I::AliasTy: Decodable<D>,
     I::BoundTy: Decodable<D>,
-    I::PlaceholderType: Decodable<D>,
+    I::PlaceholderTy: Decodable<D>,
     I::InferTy: Decodable<D>,
     I::PredicateKind: Decodable<D>,
     I::AllocId: Decodable<D>,
@@ -746,20 +746,20 @@ impl<CTX: HashStableContext, I: Interner> HashStable<CTX> for TyKind<I>
 where
     I::AdtDef: HashStable<CTX>,
     I::DefId: HashStable<CTX>,
-    I::GenericArgsRef: HashStable<CTX>,
+    I::GenericArgs: HashStable<CTX>,
     I::Ty: HashStable<CTX>,
     I::Const: HashStable<CTX>,
     I::TypeAndMut: HashStable<CTX>,
     I::PolyFnSig: HashStable<CTX>,
-    I::ListBinderExistentialPredicate: HashStable<CTX>,
+    I::BoundExistentialPredicates: HashStable<CTX>,
     I::Region: HashStable<CTX>,
     I::Movability: HashStable<CTX>,
     I::Mutability: HashStable<CTX>,
-    I::ListTy: HashStable<CTX>,
+    I::Tys: HashStable<CTX>,
     I::AliasTy: HashStable<CTX>,
     I::BoundTy: HashStable<CTX>,
     I::ParamTy: HashStable<CTX>,
-    I::PlaceholderType: HashStable<CTX>,
+    I::PlaceholderTy: HashStable<CTX>,
     I::InferTy: HashStable<CTX>,
     I::ErrorGuaranteed: HashStable<CTX>,
 {
@@ -1201,7 +1201,7 @@ pub enum RegionKind<I: Interner> {
     ReStatic,
 
     /// A region variable. Should not exist outside of type inference.
-    ReVar(I::RegionVid),
+    ReVar(I::InferRegion),
 
     /// A placeholder region -- basically, the higher-ranked version of `ReFree`.
     /// Should not exist outside of type inference.
@@ -1236,7 +1236,7 @@ where
     I::EarlyBoundRegion: Copy,
     I::BoundRegion: Copy,
     I::FreeRegion: Copy,
-    I::RegionVid: Copy,
+    I::InferRegion: Copy,
     I::PlaceholderRegion: Copy,
     I::ErrorGuaranteed: Copy,
 {
@@ -1376,7 +1376,7 @@ where
     I::EarlyBoundRegion: Encodable<E>,
     I::BoundRegion: Encodable<E>,
     I::FreeRegion: Encodable<E>,
-    I::RegionVid: Encodable<E>,
+    I::InferRegion: Encodable<E>,
     I::PlaceholderRegion: Encodable<E>,
 {
     fn encode(&self, e: &mut E) {
@@ -1411,7 +1411,7 @@ where
     I::EarlyBoundRegion: Decodable<D>,
     I::BoundRegion: Decodable<D>,
     I::FreeRegion: Decodable<D>,
-    I::RegionVid: Decodable<D>,
+    I::InferRegion: Decodable<D>,
     I::PlaceholderRegion: Decodable<D>,
     I::ErrorGuaranteed: Decodable<D>,
 {
@@ -1442,7 +1442,7 @@ where
     I::EarlyBoundRegion: HashStable<CTX>,
     I::BoundRegion: HashStable<CTX>,
     I::FreeRegion: HashStable<CTX>,
-    I::RegionVid: HashStable<CTX>,
+    I::InferRegion: HashStable<CTX>,
     I::PlaceholderRegion: HashStable<CTX>,
 {
     #[inline]