Rename ParameterKindsWithUniverseIndex to CanonicalVarKinds

Author: crlf0710

chalk-integration/src/program.rs

@@ -206,9 +206,9 @@ impl tls::DebugContext for Program {
         write!(fmt, "{:?}", parameter_kinds.inner_debug(interner))
     }
 
-    fn debug_parameter_kinds_with_universe_index(
+    fn debug_canonical_var_kinds(
         &self,
-        parameter_kinds: &chalk_ir::ParameterKindsWithUniverseIndex<ChalkIr>,
+        parameter_kinds: &chalk_ir::CanonicalVarKinds<ChalkIr>,
         fmt: &mut fmt::Formatter<'_>,
     ) -> Result<(), fmt::Error> {
         let interner = self.interner();

chalk-ir/src/cast.rs

@@ -83,7 +83,7 @@ reflexive_impl!(for(I: Interner) WhereClause<I>);
 reflexive_impl!(for(I: Interner) ProgramClause<I>);
 reflexive_impl!(for(I: Interner) QuantifiedWhereClause<I>);
 reflexive_impl!(for(I: Interner) ParameterKinds<I>);
-reflexive_impl!(for(I: Interner) ParameterKindsWithUniverseIndex<I>);
+reflexive_impl!(for(I: Interner) CanonicalVarKinds<I>);
 
 impl<I: Interner> CastTo<WhereClause<I>> for TraitRef<I> {
     fn cast_to(self, _interner: &I) -> WhereClause<I> {

chalk-ir/src/debug.rs

@@ -661,9 +661,9 @@ impl<I: Interner> Debug for Environment<I> {
     }
 }
 
-impl<I: Interner> Debug for ParameterKindsWithUniverseIndex<I> {
+impl<I: Interner> Debug for CanonicalVarKinds<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
-        I::debug_parameter_kinds_with_universe_index(self, fmt)
+        I::debug_canonical_var_kinds(self, fmt)
             .unwrap_or_else(|| write!(fmt, "{:?}", self.interned))
     }
 }

chalk-ir/src/fold/binder_impls.rs

@@ -78,10 +78,8 @@ where
             value: self_value,
         } = self;
         let value = self_value.fold_with(folder, outer_binder.shifted_in())?;
-        let binders = ParameterKindsWithUniverseIndex {
-            interned: TI::transfer_parameter_kinds_with_universe_index(
-                self_binders.interned().clone(),
-            ),
+        let binders = CanonicalVarKinds {
+            interned: TI::transfer_canonical_var_kinds(self_binders.interned().clone()),
         };
         Ok(Canonical {
             binders: binders,

chalk-ir/src/interner.rs

@@ -1,6 +1,7 @@
 use crate::AliasTy;
 use crate::ApplicationTy;
 use crate::AssocTypeId;
+use crate::CanonicalVarKinds;
 use crate::Goal;
 use crate::GoalData;
 use crate::Goals;
@@ -12,7 +13,6 @@ use crate::Parameter;
 use crate::ParameterData;
 use crate::ParameterKind;
 use crate::ParameterKinds;
-use crate::ParameterKindsWithUniverseIndex;
 use crate::ProgramClause;
 use crate::ProgramClauseData;
 use crate::ProgramClauseImplication;
@@ -139,13 +139,13 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
     type InternedParameterKinds: Debug + Clone + Eq + Hash;
 
     /// "Interned" representation of a list of parameter kind with universe index.  
-    /// In normal user code, `Self::InternedParameterKindsWithUniverseIndex` is not referenced.
-    /// Instead, we refer to `ParameterKindsWithUniverseIndex<Self>`, which wraps this type.
+    /// In normal user code, `Self::InternedCanonicalVarKinds` is not referenced.
+    /// Instead, we refer to `CanonicalVarKinds<Self>`, which wraps this type.
     ///
-    /// An `InternedParameterKindsWithUniverseIndex` is created by
-    /// `intern_parameter_kinds_with_universe_index` and can be converted back
-    /// to its underlying data via `parameter_kinds_with_universe_index_data`.
-    type InternedParameterKindsWithUniverseIndex: Debug + Clone + Eq + Hash;
+    /// An `InternedCanonicalVarKinds` is created by
+    /// `intern_canonical_var_kinds` and can be converted back
+    /// to its underlying data via `canonical_var_kinds_data`.
+    type InternedCanonicalVarKinds: Debug + Clone + Eq + Hash;
 
     /// The core "id" type used for struct-ids and the like.
     type DefId: Debug + Copy + Eq + Ord + Hash;
@@ -322,8 +322,8 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
     /// Returns `None` to fallback to the default debug output (e.g.,
     /// if no info about current program is available from TLS).
     #[allow(unused_variables)]
-    fn debug_parameter_kinds_with_universe_index(
-        parameter_kinds_with_universe_index: &ParameterKindsWithUniverseIndex<Self>,
+    fn debug_canonical_var_kinds(
+        canonical_var_kinds: &CanonicalVarKinds<Self>,
         fmt: &mut fmt::Formatter<'_>,
     ) -> Option<fmt::Result> {
         None
@@ -578,18 +578,18 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
 
     /// Create an "interned" parameter kinds with universe index from `data`. This is not
     /// normally invoked directly; instead, you invoke
-    /// `ParameterKindsWithUniverseIndex::from` (which will ultimately call this
+    /// `CanonicalVarKinds::from` (which will ultimately call this
     /// method).
-    fn intern_parameter_kinds_with_universe_index(
+    fn intern_canonical_var_kinds(
         &self,
         data: impl IntoIterator<Item = ParameterKind<UniverseIndex>>,
-    ) -> Self::InternedParameterKindsWithUniverseIndex;
+    ) -> Self::InternedCanonicalVarKinds;
 
     /// Lookup the slice of `ParameterKind` that was interned to
     /// create a `ParameterKinds`.
-    fn parameter_kinds_with_universe_index_data<'a>(
+    fn canonical_var_kinds_data<'a>(
         &self,
-        parameter_kinds_with_universe_index: &'a Self::InternedParameterKindsWithUniverseIndex,
+        canonical_var_kinds: &'a Self::InternedCanonicalVarKinds,
     ) -> &'a [ParameterKind<UniverseIndex>];
 }
 
@@ -600,9 +600,9 @@ pub trait TargetInterner<I: Interner>: Interner {
         parameter_kinds: I::InternedParameterKinds,
     ) -> Self::InternedParameterKinds;
 
-    fn transfer_parameter_kinds_with_universe_index(
-        parameter_kinds: I::InternedParameterKindsWithUniverseIndex,
-    ) -> Self::InternedParameterKindsWithUniverseIndex;
+    fn transfer_canonical_var_kinds(
+        parameter_kinds: I::InternedCanonicalVarKinds,
+    ) -> Self::InternedCanonicalVarKinds;
 }
 
 impl<I: Interner> TargetInterner<I> for I {
@@ -616,9 +616,9 @@ impl<I: Interner> TargetInterner<I> for I {
         parameter_kinds
     }
 
-    fn transfer_parameter_kinds_with_universe_index(
-        parameter_kinds: I::InternedParameterKindsWithUniverseIndex,
-    ) -> Self::InternedParameterKindsWithUniverseIndex {
+    fn transfer_canonical_var_kinds(
+        parameter_kinds: I::InternedCanonicalVarKinds,
+    ) -> Self::InternedCanonicalVarKinds {
         parameter_kinds
     }
 }
@@ -669,7 +669,7 @@ mod default {
         type InternedProgramClauses = Vec<ProgramClause<ChalkIr>>;
         type InternedQuantifiedWhereClauses = Vec<QuantifiedWhereClause<ChalkIr>>;
         type InternedParameterKinds = Vec<ParameterKind<()>>;
-        type InternedParameterKindsWithUniverseIndex = Vec<ParameterKind<UniverseIndex>>;
+        type InternedCanonicalVarKinds = Vec<ParameterKind<UniverseIndex>>;
         type DefId = RawId;
         type Identifier = Identifier;
 
@@ -759,15 +759,12 @@ mod default {
             })
         }
 
-        fn debug_parameter_kinds_with_universe_index(
-            parameter_kinds_with_universe_index: &ParameterKindsWithUniverseIndex<Self>,
+        fn debug_canonical_var_kinds(
+            canonical_var_kinds: &CanonicalVarKinds<Self>,
             fmt: &mut fmt::Formatter<'_>,
         ) -> Option<fmt::Result> {
             tls::with_current_program(|prog| {
-                Some(prog?.debug_parameter_kinds_with_universe_index(
-                    parameter_kinds_with_universe_index,
-                    fmt,
-                ))
+                Some(prog?.debug_canonical_var_kinds(canonical_var_kinds, fmt))
             })
         }
 
@@ -948,17 +945,17 @@ mod default {
         ) -> &'a [ParameterKind<()>] {
             parameter_kinds
         }
-        fn intern_parameter_kinds_with_universe_index(
+        fn intern_canonical_var_kinds(
             &self,
             data: impl IntoIterator<Item = ParameterKind<UniverseIndex>>,
-        ) -> Self::InternedParameterKindsWithUniverseIndex {
+        ) -> Self::InternedCanonicalVarKinds {
             data.into_iter().collect()
         }
-        fn parameter_kinds_with_universe_index_data<'a>(
+        fn canonical_var_kinds_data<'a>(
             &self,
-            parameter_kinds_with_universe_index: &'a Self::InternedParameterKindsWithUniverseIndex,
+            canonical_var_kinds: &'a Self::InternedCanonicalVarKinds,
         ) -> &'a [ParameterKind<UniverseIndex>] {
-            parameter_kinds_with_universe_index
+            canonical_var_kinds
         }
     }
 

chalk-ir/src/lib.rs

@@ -1548,28 +1548,25 @@ impl<I: Interner> ParameterKinds<I> {
 }
 
 #[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord, HasInterner)]
-pub struct ParameterKindsWithUniverseIndex<I: Interner> {
-    interned: I::InternedParameterKindsWithUniverseIndex,
+pub struct CanonicalVarKinds<I: Interner> {
+    interned: I::InternedCanonicalVarKinds,
 }
 
-impl<I: Interner> ParameterKindsWithUniverseIndex<I> {
+impl<I: Interner> CanonicalVarKinds<I> {
     pub fn new(interner: &I) -> Self {
         Self::from(interner, None::<ParameterKind<UniverseIndex>>)
     }
 
-    pub fn interned(&self) -> &I::InternedParameterKindsWithUniverseIndex {
+    pub fn interned(&self) -> &I::InternedCanonicalVarKinds {
         &self.interned
     }
 
     pub fn from(
         interner: &I,
         parameter_kinds: impl IntoIterator<Item = ParameterKind<UniverseIndex>>,
     ) -> Self {
-        ParameterKindsWithUniverseIndex {
-            interned: I::intern_parameter_kinds_with_universe_index(
-                interner,
-                parameter_kinds.into_iter(),
-            ),
+        CanonicalVarKinds {
+            interned: I::intern_canonical_var_kinds(interner, parameter_kinds.into_iter()),
         }
     }
 
@@ -1596,7 +1593,7 @@ impl<I: Interner> ParameterKindsWithUniverseIndex<I> {
     }
 
     pub fn as_slice(&self, interner: &I) -> &[ParameterKind<UniverseIndex>] {
-        interner.parameter_kinds_with_universe_index_data(&self.interned)
+        interner.canonical_var_kinds_data(&self.interned)
     }
 }
 
@@ -1608,7 +1605,7 @@ impl<I: Interner> ParameterKindsWithUniverseIndex<I> {
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct Canonical<T: HasInterner> {
     pub value: T,
-    pub binders: ParameterKindsWithUniverseIndex<T::Interner>,
+    pub binders: CanonicalVarKinds<T::Interner>,
 }
 
 impl<T: HasInterner> HasInterner for Canonical<T> {

chalk-ir/src/tls.rs

@@ -1,9 +1,8 @@
 use crate::interner::ChalkIr;
 use crate::{
-    debug::SeparatorTraitRef, AliasTy, ApplicationTy, AssocTypeId, Goal, Goals, Lifetime, OpaqueTy,
-    OpaqueTyId, Parameter, ParameterKinds, ParameterKindsWithUniverseIndex, ProgramClause,
-    ProgramClauseImplication, ProjectionTy, ProgramClauses, QuantifiedWhereClauses, StructId, Substitution,
-    TraitId, Ty,
+    debug::SeparatorTraitRef, AliasTy, ApplicationTy, AssocTypeId, CanonicalVarKinds, Goal, Goals,
+    Lifetime, OpaqueTy, OpaqueTyId, Parameter, ParameterKinds, ProgramClause, ProgramClauseImplication,
+    ProgramClauses, ProjectionTy, QuantifiedWhereClauses, StructId, Substitution, TraitId, Ty,
 };
 use std::cell::RefCell;
 use std::fmt;
@@ -82,9 +81,9 @@ pub trait DebugContext {
         fmt: &mut fmt::Formatter<'_>,
     ) -> Result<(), fmt::Error>;
 
-    fn debug_parameter_kinds_with_universe_index(
+    fn debug_canonical_var_kinds(
         &self,
-        parameter_kinds: &ParameterKindsWithUniverseIndex<ChalkIr>,
+        parameter_kinds: &CanonicalVarKinds<ChalkIr>,
         fmt: &mut fmt::Formatter<'_>,
     ) -> Result<(), fmt::Error>;
 

chalk-solve/src/infer/canonicalize.rs

@@ -74,14 +74,14 @@ struct Canonicalizer<'q, I: Interner> {
 }
 
 impl<'q, I: Interner> Canonicalizer<'q, I> {
-    fn into_binders(self) -> ParameterKindsWithUniverseIndex<I> {
+    fn into_binders(self) -> CanonicalVarKinds<I> {
         let Canonicalizer {
             table,
             free_vars,
             interner,
             ..
         } = self;
-        ParameterKindsWithUniverseIndex::from(
+        CanonicalVarKinds::from(
             interner,
             free_vars
                 .into_iter()

chalk-solve/src/infer/test.rs

@@ -181,7 +181,7 @@ fn quantify_simple() {
             .quantified,
         Canonical {
             value: ty!(apply (item 0) (bound 0) (bound 1) (bound 2)),
-            binders: ParameterKindsWithUniverseIndex::from(
+            binders: CanonicalVarKinds::from(
                 interner,
                 vec![
                     ParameterKind::Ty(U2),
@@ -222,7 +222,7 @@ fn quantify_bound() {
             .quantified,
         Canonical {
             value: ty!(apply (item 0) (apply (item 1) (bound 0) (bound 1)) (bound 2) (bound 0) (bound 1)),
-            binders: ParameterKindsWithUniverseIndex::from(
+            binders: CanonicalVarKinds::from(
                 interner,
                 vec![
                     ParameterKind::Ty(U1),
@@ -266,7 +266,7 @@ fn quantify_ty_under_binder() {
             .quantified,
         Canonical {
             value: ty!(function 3 (apply (item 0) (bound 1) (bound 1 0) (bound 1 0) (lifetime (bound 1 1)))),
-            binders: ParameterKindsWithUniverseIndex::from(
+            binders: CanonicalVarKinds::from(
                 interner,
                 vec![ParameterKind::Ty(U0), ParameterKind::Lifetime(U0)]
             ),

chalk-solve/src/infer/ucanonicalize.rs

@@ -41,7 +41,7 @@ impl<I: Interner> InferenceTable<I> {
                 DebruijnIndex::INNERMOST,
             )
             .unwrap();
-        let binders = ParameterKindsWithUniverseIndex::from(
+        let binders = CanonicalVarKinds::from(
             interner,
             value0
                 .binders