Switch Vec<ParameterKind<UniverseIndex>> to ParameterKindsWithUniverseIndex<I>

Author: crlf0710

chalk-engine/src/forest.rs

@@ -113,6 +113,23 @@ pub enum SubstitutionResult<S> {
     Floundered,
 }
 
+impl<S> SubstitutionResult<S> {
+    pub fn as_ref(&self) -> SubstitutionResult<&S> {
+        match self {
+            SubstitutionResult::Definite(subst) => SubstitutionResult::Definite(subst),
+            SubstitutionResult::Ambiguous(subst) => SubstitutionResult::Ambiguous(subst),
+            SubstitutionResult::Floundered => SubstitutionResult::Floundered,
+        }
+    }
+    pub fn map<U, F: FnOnce(S) -> U>(self, f: F) -> SubstitutionResult<U> {
+        match self {
+            SubstitutionResult::Definite(subst) => SubstitutionResult::Definite(f(subst)),
+            SubstitutionResult::Ambiguous(subst) => SubstitutionResult::Ambiguous(f(subst)),
+            SubstitutionResult::Floundered => SubstitutionResult::Floundered,
+        }
+    }
+}
+
 impl<S: Display> Display for SubstitutionResult<S> {
     fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {

chalk-engine/src/lib.rs

@@ -278,3 +278,5 @@ impl Minimums {
         min(self.positive, self.negative)
     }
 }
+
+

chalk-integration/src/program.rs

@@ -188,6 +188,24 @@ impl tls::DebugContext for Program {
         write!(fmt, "{:?}", parameter.data(interner).inner_debug())
     }
 
+    fn debug_parameter_kinds(
+        &self,
+        parameter_kinds: &chalk_ir::ParameterKinds<ChalkIr>,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Result<(), fmt::Error> {
+        let interner = self.interner();
+        write!(fmt, "{:?}", parameter_kinds.as_slice(interner))
+    }
+
+    fn debug_parameter_kinds_with_universe_index(
+        &self,
+        parameter_kinds: &chalk_ir::ParameterKindsWithUniverseIndex<ChalkIr>,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Result<(), fmt::Error> {
+        let interner = self.interner();
+        write!(fmt, "{:?}", parameter_kinds.as_slice(interner))
+    }
+
     fn debug_goal(
         &self,
         goal: &Goal<ChalkIr>,

chalk-ir/src/cast.rs

@@ -82,6 +82,8 @@ reflexive_impl!(for(I: Interner) Goal<I>);
 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>);
 
 impl<I: Interner> CastTo<WhereClause<I>> for TraitRef<I> {
     fn cast_to(self, _interner: &I) -> WhereClause<I> {
@@ -268,16 +270,16 @@ where
 impl<T, U> CastTo<Canonical<U>> for Canonical<T>
 where
     T: CastTo<U> + HasInterner,
-    U: HasInterner,
+    U: HasInterner<Interner = T::Interner>,
 {
-    fn cast_to(self, interner: &U::Interner) -> Canonical<U> {
+    fn cast_to(self, interner: &T::Interner) -> Canonical<U> {
         // Subtle point: It should be ok to re-use the binders here,
         // because `cast()` never introduces new inference variables,
         // nor changes the "substance" of the type we are working
         // with. It just introduces new wrapper types.
         Canonical {
             value: self.value.cast(interner),
-            binders: self.binders,
+            binders: self.binders.cast(interner),
         }
     }
 }

chalk-ir/src/debug.rs

@@ -636,10 +636,32 @@ impl<I: Interner> Debug for Environment<I> {
     }
 }
 
-impl<T: Display> Display for Canonical<T> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
-        let Canonical { binders, value } = self;
+impl<I: Interner> Debug for ParameterKindsWithUniverseIndex<I> {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
+        I::debug_parameter_kinds_with_universe_index(self, fmt)
+            .unwrap_or_else(|| write!(fmt, "{:?}", self.interned))
+    }
+}
+
+impl<T: HasInterner + Display> Canonical<T> {
+    pub fn display<'a>(&'a self, interner: &'a T::Interner) -> CanonicalDisplay<'a, T> {
+        CanonicalDisplay {
+            canonical: self,
+            interner,
+        }
+    }
+}
 
+pub struct CanonicalDisplay<'a, T: HasInterner> {
+    canonical: &'a Canonical<T>,
+    interner: &'a T::Interner,
+}
+
+impl<'a, T: HasInterner + Display> Display for CanonicalDisplay<'a, T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+        let Canonical { binders, value } = self.canonical;
+        let interner = self.interner;
+        let binders = binders.as_slice(interner);
         if binders.is_empty() {
             // Ordinarily, we try to print all binder levels, if they
             // are empty, but we can skip in this *particular* case
@@ -665,6 +687,17 @@ impl<T: Display> Display for Canonical<T> {
     }
 }
 
+pub struct CanonicalDisplay<'a, I: Interner, T> {
+    canonical: &'a Canonical<I, T>,
+    interner: &'a I,
+}
+
+impl<'a, I: Interner, T: Display> Display for CanonicalDisplay<'a, I, T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+        DisplayWithInterner::fmt_with_interner(self.canonical, self.interner, f)
+    }
+}
+
 impl<T: Debug, L: Debug> Debug for ParameterKind<T, L> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
         match *self {

chalk-ir/src/fold/binder_impls.rs

@@ -55,10 +55,11 @@ where
     }
 }
 
-impl<T, I, TI> Fold<I, TI> for Canonical<T>
+impl<I, T, TI> Fold<I, TI> for Canonical<T>
 where
-    T: Fold<I, TI>,
     I: Interner,
+    T: HasInterner<Interner = I> + Fold<I, TI>,
+    <T as Fold<I, TI>>::Result: HasInterner<Interner = TI>,
     TI: TargetInterner<I>,
 {
     type Result = Canonical<T::Result>;
@@ -76,8 +77,13 @@ 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(),
+            ),
+        };
         Ok(Canonical {
-            binders: self_binders.clone(),
+            binders: binders,
             value: value,
         })
     }

chalk-ir/src/interner.rs

@@ -11,6 +11,8 @@ use crate::OpaqueTyId;
 use crate::Parameter;
 use crate::ParameterData;
 use crate::ParameterKind;
+use crate::ParameterKinds;
+use crate::ParameterKindsWithUniverseIndex;
 use crate::ProgramClause;
 use crate::ProgramClauseData;
 use crate::ProgramClauseImplication;
@@ -282,6 +284,36 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
         None
     }
 
+    /// Prints the debug representation of a parameter kinds list. To get good
+    /// results, this requires inspecting TLS, and is difficult to
+    /// code without reference to a specific interner (and hence
+    /// fully known types).
+    ///
+    /// 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(
+        parameter_kinds: &ParameterKinds<Self>,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Option<fmt::Result> {
+        None
+    }
+
+    /// Prints the debug representation of an parameter kinds list with universe index.
+    /// To get good results, this requires inspecting TLS, and is difficult to
+    /// code without reference to a specific interner (and hence
+    /// fully known types).
+    ///
+    /// 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>,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Option<fmt::Result> {
+        None
+    }
+
     /// Prints the debug representation of an goal. To get good
     /// results, this requires inspecting TLS, and is difficult to
     /// code without reference to a specific interner (and hence
@@ -548,12 +580,22 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
 
 pub trait TargetInterner<I: Interner>: Interner {
     fn transfer_def_id(def_id: I::DefId) -> Self::DefId;
+
+    fn transfer_parameter_kinds_with_universe_index(
+        parameter_kinds: I::InternedParameterKindsWithUniverseIndex,
+    ) -> Self::InternedParameterKindsWithUniverseIndex;
 }
 
 impl<I: Interner> TargetInterner<I> for I {
     fn transfer_def_id(def_id: I::DefId) -> Self::DefId {
         def_id
     }
+
+    fn transfer_parameter_kinds_with_universe_index(
+        parameter_kinds: I::InternedParameterKindsWithUniverseIndex,
+    ) -> Self::InternedParameterKindsWithUniverseIndex {
+        parameter_kinds
+    }
 }
 
 /// Implemented by types that have an associated interner (which
@@ -674,6 +716,27 @@ mod default {
             tls::with_current_program(|prog| Some(prog?.debug_parameter(parameter, fmt)))
         }
 
+        fn debug_parameter_kinds(
+            parameter_kinds: &ParameterKinds<Self>,
+            fmt: &mut fmt::Formatter<'_>,
+        ) -> Option<fmt::Result> {
+            tls::with_current_program(|prog| {
+                Some(prog?.debug_parameter_kinds(parameter_kinds, fmt))
+            })
+        }
+
+        fn debug_parameter_kinds_with_universe_index(
+            parameter_kinds_with_universe_index: &ParameterKindsWithUniverseIndex<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,
+                ))
+            })
+        }
+
         fn debug_goal(goal: &Goal<ChalkIr>, fmt: &mut fmt::Formatter<'_>) -> Option<fmt::Result> {
             tls::with_current_program(|prog| Some(prog?.debug_goal(goal, fmt)))
         }

chalk-ir/src/lib.rs

@@ -1596,16 +1596,13 @@ impl<I: Interner> ParameterKindsWithUniverseIndex<I> {
 /// All unresolved existential variables are "renumbered" according to their
 /// first appearance; the kind/universe of the variable is recorded in the
 /// `binders` field.
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Canonical<T> {
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Canonical<T: HasInterner> {
     pub value: T,
-    pub binders: Vec<ParameterKind<UniverseIndex>>,
+    pub binders: ParameterKindsWithUniverseIndex<T::Interner>,
 }
 
-impl<T> HasInterner for Canonical<T>
-where
-    T: HasInterner,
-{
+impl<T: HasInterner> HasInterner for Canonical<T> {
     type Interner = T::Interner;
 }
 
@@ -1615,21 +1612,21 @@ where
 /// distinctions.
 ///
 /// To produce one of these values, use the `u_canonicalize` method.
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct UCanonical<T> {
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct UCanonical<T: HasInterner> {
     pub canonical: Canonical<T>,
     pub universes: usize,
 }
 
-impl<T> UCanonical<T> {
-    pub fn is_trivial_substitution<I: Interner>(
+impl<T: HasInterner> UCanonical<T> {
+    pub fn is_trivial_substitution(
         &self,
-        interner: &I,
-        canonical_subst: &Canonical<AnswerSubst<I>>,
+        interner: &T::Interner,
+        canonical_subst: &Canonical<AnswerSubst<T::Interner>>,
     ) -> bool {
         let subst = &canonical_subst.value.subst;
         assert_eq!(
-            self.canonical.binders.len(),
+            self.canonical.binders.len(interner),
             subst.parameters(interner).len()
         );
         subst.is_identity_subst(interner)

chalk-ir/src/tls.rs

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

chalk-ir/src/visit/binder_impls.rs

@@ -37,10 +37,10 @@ where
     }
 }
 
-impl<T, I> Visit<I> for Canonical<T>
+impl<I, T> Visit<I> for Canonical<T>
 where
-    T: Visit<I>,
     I: Interner,
+    T: HasInterner<Interner = I> + Visit<I>,
 {
     fn visit_with<'i, R: VisitResult>(
         &self,