Switch Vec<ParameterKind<()>> to ParameterKinds<I>.

Author: crlf0710

chalk-engine/src/lib.rs

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

chalk-integration/src/lib.rs

@@ -11,6 +11,7 @@ pub mod program;
 pub mod program_environment;
 pub mod query;
 
+use chalk_ir::interner::{ChalkIr, HasInterner};
 pub use chalk_ir::interner::{Identifier, RawId};
 use chalk_ir::Binders;
 
@@ -20,9 +21,16 @@ pub enum TypeSort {
     Trait,
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct Unit;
+
+impl HasInterner for Unit {
+    type Interner = ChalkIr;
+}
+
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct TypeKind {
     pub sort: TypeSort,
     pub name: Identifier,
-    pub binders: Binders<()>,
+    pub binders: Binders<Unit>,
 }

chalk-integration/src/lowering.rs

@@ -1,8 +1,8 @@
 use chalk_ir::cast::{Cast, Caster};
-use chalk_ir::interner::ChalkIr;
+use chalk_ir::interner::{ChalkIr, HasInterner};
 use chalk_ir::{
-    self, AssocTypeId, BoundVar, DebruijnIndex, ImplId, QuantifiedWhereClauses, StructId,
-    Substitution, TraitId,
+    self, AssocTypeId, BoundVar, DebruijnIndex, ImplId, ParameterKinds, QuantifiedWhereClauses,
+    StructId, Substitution, TraitId,
 };
 use chalk_parse::ast::*;
 use chalk_rust_ir as rust_ir;
@@ -165,11 +165,16 @@ impl<'k> Env<'k> {
     where
         I: IntoIterator<Item = chalk_ir::ParameterKind<Ident>>,
         I::IntoIter: ExactSizeIterator,
+        T: HasInterner<Interner = ChalkIr>,
         OP: FnOnce(&Self) -> LowerResult<T>,
     {
+        let interner = &ChalkIr;
         let binders: Vec<_> = binders.into_iter().collect();
         let env = self.introduce(binders.iter().cloned())?;
-        Ok(chalk_ir::Binders::new(binders.anonymize(), op(&env)?))
+        Ok(chalk_ir::Binders::new(
+            ParameterKinds::from(interner, binders.anonymize()),
+            op(&env)?,
+        ))
     }
 }
 
@@ -522,10 +527,14 @@ trait LowerWhereClauses {
 
 impl LowerTypeKind for StructDefn {
     fn lower_type_kind(&self) -> LowerResult<TypeKind> {
+        let interner = &ChalkIr;
         Ok(TypeKind {
             sort: TypeSort::Struct,
             name: self.name.str,
-            binders: chalk_ir::Binders::new(self.all_parameters().anonymize(), ()),
+            binders: chalk_ir::Binders::new(
+                ParameterKinds::from(interner, self.all_parameters().anonymize()),
+                crate::Unit,
+            ),
         })
     }
 }
@@ -538,14 +547,15 @@ impl LowerWhereClauses for StructDefn {
 
 impl LowerTypeKind for TraitDefn {
     fn lower_type_kind(&self) -> LowerResult<TypeKind> {
+        let interner = &ChalkIr;
         let binders: Vec<_> = self.parameter_kinds.iter().map(|p| p.lower()).collect();
         Ok(TypeKind {
             sort: TypeSort::Trait,
             name: self.name.str,
             binders: chalk_ir::Binders::new(
                 // for the purposes of the *type*, ignore `Self`:
-                binders.anonymize(),
-                (),
+                ParameterKinds::from(interner, binders.anonymize()),
+                crate::Unit,
             ),
         })
     }
@@ -751,6 +761,7 @@ trait LowerTraitBound {
 
 impl LowerTraitBound for TraitBound {
     fn lower(&self, env: &Env) -> LowerResult<rust_ir::TraitBound<ChalkIr>> {
+        let interner = &ChalkIr;
         let trait_id = env.lookup_trait(self.trait_name)?;
 
         let k = env.trait_kind(trait_id);
@@ -764,15 +775,15 @@ impl LowerTraitBound for TraitBound {
             .map(|a| Ok(a.lower(env)?))
             .collect::<LowerResult<Vec<_>>>()?;
 
-        if parameters.len() != k.binders.len() {
+        if parameters.len() != k.binders.len(interner) {
             Err(RustIrError::IncorrectNumberOfTypeParameters {
                 identifier: self.trait_name,
-                expected: k.binders.len(),
+                expected: k.binders.len(interner),
                 actual: parameters.len(),
             })?;
         }
 
-        for (binder, param) in k.binders.binders.iter().zip(parameters.iter()) {
+        for (binder, param) in k.binders.binders.iter(interner).zip(parameters.iter()) {
             if binder.kind() != param.kind() {
                 Err(RustIrError::IncorrectTraitParameterKind {
                     identifier: self.trait_name,
@@ -978,10 +989,10 @@ impl LowerTy for Ty {
             Ty::Id { name } => match env.lookup_type(name)? {
                 TypeLookup::Struct(id) => {
                     let k = env.struct_kind(id);
-                    if k.binders.len() > 0 {
+                    if k.binders.len(interner) > 0 {
                         Err(RustIrError::IncorrectNumberOfTypeParameters {
                             identifier: name,
-                            expected: k.binders.len(),
+                            expected: k.binders.len(interner),
                             actual: 0,
                         })
                     } else {
@@ -1025,10 +1036,10 @@ impl LowerTy for Ty {
                 };
 
                 let k = env.struct_kind(id);
-                if k.binders.len() != args.len() {
+                if k.binders.len(interner) != args.len() {
                     Err(RustIrError::IncorrectNumberOfTypeParameters {
                         identifier: name,
-                        expected: k.binders.len(),
+                        expected: k.binders.len(interner),
                         actual: args.len(),
                     })?;
                 }
@@ -1038,7 +1049,7 @@ impl LowerTy for Ty {
                     args.iter().map(|t| Ok(t.lower(env)?)),
                 )?;
 
-                for (param, arg) in k.binders.binders.iter().zip(args.iter()) {
+                for (param, arg) in k.binders.binders.iter(interner).zip(args.iter()) {
                     if param.kind() != arg.kind() {
                         Err(RustIrError::IncorrectParameterKind {
                             identifier: name,
@@ -1267,14 +1278,16 @@ pub trait LowerGoal<A> {
 
 impl LowerGoal<LoweredProgram> for Goal {
     fn lower(&self, program: &LoweredProgram) -> LowerResult<chalk_ir::Goal<ChalkIr>> {
+        let interner = &ChalkIr;
         let associated_ty_lookups: BTreeMap<_, _> = program
             .associated_ty_data
             .iter()
             .map(|(&associated_ty_id, datum)| {
                 let trait_datum = &program.trait_data[&datum.trait_id];
-                let num_trait_params = trait_datum.binders.len();
-                let num_addl_params = datum.binders.len() - num_trait_params;
-                let addl_parameter_kinds = datum.binders.binders[..num_addl_params].to_owned();
+                let num_trait_params = trait_datum.binders.len(interner);
+                let num_addl_params = datum.binders.len(interner) - num_trait_params;
+                let addl_parameter_kinds =
+                    datum.binders.binders.as_slice(interner)[..num_addl_params].to_owned();
                 let lookup = AssociatedTyLookup {
                     id: associated_ty_id,
                     addl_parameter_kinds,

chalk-integration/src/program.rs

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

chalk-ir/src/cast.rs

@@ -140,7 +140,7 @@ impl<I: Interner> CastTo<Goal<I>> for EqGoal<I> {
     }
 }
 
-impl<T: CastTo<Goal<I>>, I: Interner> CastTo<Goal<I>> for Binders<T> {
+impl<I: Interner, T: HasInterner<Interner = I> + CastTo<Goal<I>>> CastTo<Goal<I>> for Binders<T> {
     fn cast_to(self, interner: &I) -> Goal<I> {
         GoalData::Quantified(
             QuantifierKind::ForAll,
@@ -194,10 +194,10 @@ where
     }
 }
 
-impl<T, I> CastTo<ProgramClause<I>> for Binders<T>
+impl<I, T> CastTo<ProgramClause<I>> for Binders<T>
 where
-    T: CastTo<DomainGoal<I>>,
     I: Interner,
+    T: HasInterner<Interner = I> + CastTo<DomainGoal<I>>,
 {
     fn cast_to(self, interner: &I) -> ProgramClause<I> {
         ProgramClauseData::ForAll(self.map(|bound| ProgramClauseImplication {

chalk-ir/src/could_match.rs

@@ -50,7 +50,7 @@ where
 
             fn zip_binders<T>(&mut self, a: &Binders<T>, b: &Binders<T>) -> Fallible<()>
             where
-                T: Zip<I>,
+                T: HasInterner + Zip<I>,
             {
                 Zip::zip_with(self, &a.value, &b.value)
             }

chalk-ir/src/debug.rs

@@ -187,22 +187,64 @@ impl<I: Interner> Debug for LifetimeData<I> {
     }
 }
 
+impl<I: Interner> ParameterKinds<I> {
+    fn debug(&self) -> ParameterKindsDebug<'_, I> {
+        ParameterKindsDebug(self)
+    }
+
+    pub fn inner_debug<'a>(&'a self, interner: &'a I) -> ParameterKindsInnerDebug<'a, I> {
+        ParameterKindsInnerDebug {
+            parameter_kinds: self,
+            interner,
+        }
+    }
+}
+
+struct ParameterKindsDebug<'a, I: Interner>(&'a ParameterKinds<I>);
+
+impl<'a, I: Interner> Debug for ParameterKindsDebug<'a, I> {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
+        I::debug_parameter_kinds_with_angles(self.0, fmt)
+            .unwrap_or_else(|| write!(fmt, "{:?}", self.0.interned))
+    }
+}
+
+pub struct ParameterKindsInnerDebug<'a, I: Interner> {
+    parameter_kinds: &'a ParameterKinds<I>,
+    interner: &'a I,
+}
+
+impl<'a, I: Interner> Debug for ParameterKindsInnerDebug<'a, I> {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
+        // NB: We always print the `for<>`, even if it is empty,
+        // because it may affect the debruijn indices of things
+        // contained within. For example, `for<> { ^1.0 }` is very
+        // different from `^1.0` in terms of what variable is being
+        // referenced.
+        write!(fmt, "<")?;
+        for (index, binder) in self.parameter_kinds.iter(self.interner).enumerate() {
+            if index > 0 {
+                write!(fmt, ", ")?;
+            }
+            match *binder {
+                ParameterKind::Ty(()) => write!(fmt, "type")?,
+                ParameterKind::Lifetime(()) => write!(fmt, "lifetime")?,
+            }
+        }
+        write!(fmt, ">")
+    }
+}
+
 impl<I: Interner> Debug for GoalData<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
         match self {
-            GoalData::Quantified(qkind, ref subgoal) => {
-                write!(fmt, "{:?}<", qkind)?;
-                for (index, binder) in subgoal.binders.iter().enumerate() {
-                    if index > 0 {
-                        write!(fmt, ", ")?;
-                    }
-                    match *binder {
-                        ParameterKind::Ty(()) => write!(fmt, "type")?,
-                        ParameterKind::Lifetime(()) => write!(fmt, "lifetime")?,
-                    }
-                }
-                write!(fmt, "> {{ {:?} }}", subgoal.value)
-            }
+            GoalData::Quantified(qkind, ref subgoal) => write!(
+                fmt,
+                "{:?}{:?} {{ {:?} }}",
+                qkind,
+                subgoal.binders.debug(),
+                subgoal.value
+            ),
             GoalData::Implies(ref wc, ref g) => write!(fmt, "if ({:?}) {{ {:?} }}", wc, g),
             GoalData::All(ref goals) => write!(fmt, "all{:?}", goals),
             GoalData::Not(ref g) => write!(fmt, "not {{ {:?} }}", g),
@@ -511,30 +553,13 @@ impl<I: Interner> Debug for EqGoal<I> {
     }
 }
 
-impl<T: Debug> Debug for Binders<T> {
+impl<T: HasInterner + Debug> Debug for Binders<T> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
         let Binders {
             ref binders,
             ref value,
         } = *self;
-
-        // NB: We always print the `for<>`, even if it is empty,
-        // because it may affect the debruijn indices of things
-        // contained within. For example, `for<> { ^1.0 }` is very
-        // different from `^1.0` in terms of what variable is being
-        // referenced.
-
-        write!(fmt, "for<")?;
-        for (index, binder) in binders.iter().enumerate() {
-            if index > 0 {
-                write!(fmt, ", ")?;
-            }
-            match *binder {
-                ParameterKind::Ty(()) => write!(fmt, "type")?,
-                ParameterKind::Lifetime(()) => write!(fmt, "lifetime")?,
-            }
-        }
-        write!(fmt, "> ")?;
+        write!(fmt, "for{:?} ", binders.debug())?;
         Debug::fmt(value, fmt)
     }
 }
@@ -605,17 +630,6 @@ impl<'a, T: HasInterner + Display> Display for CanonicalDisplay<'a, 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

@@ -30,7 +30,8 @@ impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Fn<I> {
 
 impl<T, I: Interner, TI: TargetInterner<I>> Fold<I, TI> for Binders<T>
 where
-    T: Fold<I, TI>,
+    T: HasInterner<Interner = I> + Fold<I, TI>,
+    <T as Fold<I, TI>>::Result: HasInterner<Interner = TI>,
     I: Interner,
 {
     type Result = Binders<T::Result>;
@@ -48,10 +49,10 @@ where
             value: self_value,
         } = self;
         let value = self_value.fold_with(folder, outer_binder.shifted_in())?;
-        Ok(Binders {
-            binders: self_binders.clone(),
-            value: value,
-        })
+        let binders = ParameterKinds {
+            interned: TI::transfer_parameter_kinds(self_binders.interned().clone()),
+        };
+        Ok(Binders::new(binders, value))
     }
 }