Intern Vec<ProgramClause<I>>

chalk-integration/src/lowering.rs

@@ -1198,7 +1198,7 @@ impl LowerClause for Clause {
             .into_iter()
             .map(
                 |implication: chalk_ir::Binders<chalk_ir::ProgramClauseImplication<ChalkIr>>| {
-                    chalk_ir::ProgramClause::ForAll(implication)
+                    chalk_ir::ProgramClauseData::ForAll(implication).intern(interner)
                 },
             )
             .collect();

chalk-integration/src/program.rs

@@ -173,6 +173,15 @@ impl tls::DebugContext for Program {
         write!(fmt, "{:?}", pci.debug(interner))
     }
 
+    fn debug_program_clause(
+        &self,
+        clause: &ProgramClause<ChalkIr>,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Result<(), fmt::Error> {
+        let interner = self.interner();
+        write!(fmt, "{:?}", clause.data(interner))
+    }
+
     fn debug_application_ty(
         &self,
         application_ty: &ApplicationTy<ChalkIr>,

chalk-ir/src/cast.rs

@@ -183,10 +183,11 @@ where
     I: Interner,
 {
     fn cast_to(self, interner: &I) -> ProgramClause<I> {
-        ProgramClause::Implies(ProgramClauseImplication {
+        ProgramClauseData::Implies(ProgramClauseImplication {
             consequence: self.cast(interner),
             conditions: Goals::new(interner),
         })
+        .intern(interner)
     }
 }
 
@@ -196,22 +197,23 @@ where
     I: Interner,
 {
     fn cast_to(self, interner: &I) -> ProgramClause<I> {
-        ProgramClause::ForAll(self.map(|bound| ProgramClauseImplication {
+        ProgramClauseData::ForAll(self.map(|bound| ProgramClauseImplication {
             consequence: bound.cast(interner),
             conditions: Goals::new(interner),
         }))
+        .intern(interner)
     }
 }
 
 impl<I: Interner> CastTo<ProgramClause<I>> for ProgramClauseImplication<I> {
-    fn cast_to(self, _interner: &I) -> ProgramClause<I> {
-        ProgramClause::Implies(self)
+    fn cast_to(self, interner: &I) -> ProgramClause<I> {
+        ProgramClauseData::Implies(self).intern(interner)
     }
 }
 
 impl<I: Interner> CastTo<ProgramClause<I>> for Binders<ProgramClauseImplication<I>> {
-    fn cast_to(self, _interner: &I) -> ProgramClause<I> {
-        ProgramClause::ForAll(self)
+    fn cast_to(self, interner: &I) -> ProgramClause<I> {
+        ProgramClauseData::ForAll(self).intern(interner)
     }
 }
 

chalk-ir/src/could_match.rs

@@ -62,14 +62,20 @@ where
     }
 }
 
-impl<I: Interner> CouldMatch<DomainGoal<I>> for ProgramClause<I> {
+impl<I: Interner> CouldMatch<DomainGoal<I>> for ProgramClauseData<I> {
     fn could_match(&self, interner: &I, other: &DomainGoal<I>) -> bool {
         match self {
-            ProgramClause::Implies(implication) => {
+            ProgramClauseData::Implies(implication) => {
                 implication.consequence.could_match(interner, other)
             }
 
-            ProgramClause::ForAll(clause) => clause.value.consequence.could_match(interner, other),
+            ProgramClauseData::ForAll(clause) => clause.value.consequence.could_match(interner, other),
         }
     }
 }
+
+impl<I: Interner> CouldMatch<DomainGoal<I>> for ProgramClause<I> {
+    fn could_match(&self, interner: &I, other: &DomainGoal<I>) -> bool {
+        self.data(interner).could_match(interner, other)
+    }
+}

chalk-ir/src/debug.rs

@@ -58,6 +58,13 @@ impl<I: Interner> Debug for ProgramClauseImplication<I> {
     }
 }
 
+impl<I: Interner> Debug for ProgramClause<I> {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
+        I::debug_program_clause(self, fmt)
+            .unwrap_or_else(|| write!(fmt, "{:?}", self.clause))
+    }
+}
+
 impl<I: Interner> Debug for ApplicationTy<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
         I::debug_application_ty(self, fmt).unwrap_or_else(|| write!(fmt, "ApplicationTy(?)"))
@@ -520,11 +527,11 @@ impl<T: Debug> Debug for Binders<T> {
     }
 }
 
-impl<I: Interner> Debug for ProgramClause<I> {
+impl<I: Interner> Debug for ProgramClauseData<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
         match self {
-            ProgramClause::Implies(pc) => write!(fmt, "{:?}", pc),
-            ProgramClause::ForAll(pc) => write!(fmt, "{:?}", pc),
+            ProgramClauseData::Implies(pc) => write!(fmt, "{:?}", pc),
+            ProgramClauseData::ForAll(pc) => write!(fmt, "{:?}", pc),
         }
     }
 }

chalk-ir/src/fold/boring_impls.rs

@@ -228,7 +228,7 @@ id_fold!(StructId);
 id_fold!(TraitId);
 id_fold!(AssocTypeId);
 
-impl<I: Interner, TI: TargetInterner<I>> SuperFold<I, TI> for ProgramClause<I> {
+impl<I: Interner, TI: TargetInterner<I>> SuperFold<I, TI> for ProgramClauseData<I> {
     fn super_fold_with<'i>(
         &self,
         folder: &mut dyn Folder<'i, I, TI>,
@@ -239,16 +239,31 @@ impl<I: Interner, TI: TargetInterner<I>> SuperFold<I, TI> for ProgramClause<I> {
         TI: 'i,
     {
         match self {
-            ProgramClause::Implies(pci) => {
-                Ok(ProgramClause::Implies(pci.fold_with(folder, outer_binder)?))
+            ProgramClauseData::Implies(pci) => {
+                Ok(ProgramClauseData::Implies(pci.fold_with(folder, outer_binder)?))
             }
-            ProgramClause::ForAll(pci) => {
-                Ok(ProgramClause::ForAll(pci.fold_with(folder, outer_binder)?))
+            ProgramClauseData::ForAll(pci) => {
+                Ok(ProgramClauseData::ForAll(pci.fold_with(folder, outer_binder)?))
             }
         }
     }
 }
 
+impl<I: Interner, TI: TargetInterner<I>> SuperFold<I, TI> for ProgramClause<I> {
+    fn super_fold_with<'i>(
+        &self,
+        folder: &mut dyn Folder<'i, I, TI>,
+        outer_binder: DebruijnIndex,
+    ) -> ::chalk_engine::fallible::Fallible<Self::Result>
+    where
+        I: 'i,
+        TI: 'i,
+    {
+        let clause = self.data(folder.interner());
+        Ok(clause.super_fold_with(folder, outer_binder)?.intern(folder.target_interner()))
+    }
+}
+
 impl<I: Interner, TI: TargetInterner<I>> Fold<I, TI> for PhantomData<I> {
     type Result = PhantomData<TI>;
 

chalk-ir/src/interner.rs

@@ -8,6 +8,8 @@ use crate::Lifetime;
 use crate::LifetimeData;
 use crate::Parameter;
 use crate::ParameterData;
+use crate::ProgramClause;
+use crate::ProgramClauseData;
 use crate::ProgramClauseImplication;
 use crate::SeparatorTraitRef;
 use crate::StructId;
@@ -94,6 +96,14 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
     /// converted back to its underlying data via `substitution_data`.
     type InternedSubstitution: Debug + Clone + Eq + Hash;
 
+    /// "Interned" representation of a "program clause".  In normal user code,
+    /// `Self::InternedProgramClause` is not referenced. Instead, we refer to
+    /// `ProgramClause<Self>`, which wraps this type.
+    ///
+    /// An `InternedProgramClause` is created by `intern_program_clause` and can be
+    /// converted back to its underlying data via `program_clause_data`.
+    type InternedProgramClause: Debug + Clone + Eq + Hash;
+
     /// The core "id" type used for struct-ids and the like.
     type DefId: Debug + Copy + Eq + Ord + Hash;
 
@@ -234,6 +244,21 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
         None
     }
 
+    /// Prints the debug representation of a ProgramClause. 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_program_clause(
+        clause: &ProgramClause<Self>,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Option<fmt::Result> {
+        None
+    }
+
     /// Prints the debug representation of an ApplicationTy. To get good
     /// results, this requires inspecting TLS, and is difficult to
     /// code without reference to a specific interner (and hence
@@ -337,6 +362,18 @@ pub trait Interner: Debug + Copy + Eq + Ord + Hash {
         &self,
         substitution: &'a Self::InternedSubstitution,
     ) -> &'a [Parameter<Self>];
+
+    /// Create an "interned" program clause from `data`. This is not
+    /// normally invoked directly; instead, you invoke
+    /// `ProgramClauseData::intern` (which will ultimately call this
+    /// method).
+    fn intern_program_clause(&self, data: ProgramClauseData<Self>) -> Self::InternedProgramClause;
+
+    /// Lookup the `ProgramClauseData` that was interned to create a `ProgramClause`.
+    fn program_clause_data<'a>(
+        &self,
+        clause: &'a Self::InternedProgramClause,
+    ) -> &'a ProgramClauseData<Self>;
 }
 
 pub trait TargetInterner<I: Interner>: Interner {
@@ -391,6 +428,7 @@ mod default {
         type InternedGoal = Arc<GoalData<ChalkIr>>;
         type InternedGoals = Vec<Goal<ChalkIr>>;
         type InternedSubstitution = Vec<Parameter<ChalkIr>>;
+        type InternedProgramClause = ProgramClauseData<ChalkIr>;
         type DefId = RawId;
         type Identifier = Identifier;
 
@@ -459,6 +497,13 @@ mod default {
             tls::with_current_program(|prog| Some(prog?.debug_program_clause_implication(pci, fmt)))
         }
 
+        fn debug_program_clause(
+            clause: &ProgramClause<ChalkIr>,
+            fmt: &mut fmt::Formatter<'_>,
+        ) -> Option<fmt::Result> {
+            tls::with_current_program(|prog| Some(prog?.debug_program_clause(clause, fmt)))
+        }
+
         fn debug_application_ty(
             application_ty: &ApplicationTy<ChalkIr>,
             fmt: &mut fmt::Formatter<'_>,
@@ -544,6 +589,20 @@ mod default {
         ) -> &'a [Parameter<ChalkIr>] {
             substitution
         }
+
+        fn intern_program_clause(
+            &self,
+            data: ProgramClauseData<Self>,
+        ) -> ProgramClauseData<Self> {
+            data
+        }
+
+        fn program_clause_data<'a>(
+            &self,
+            clause: &'a ProgramClauseData<Self>,
+        ) -> &'a ProgramClauseData<Self> {
+            clause
+        }
     }
 
     impl HasInterner for ChalkIr {

chalk-ir/src/lib.rs

@@ -1208,8 +1208,8 @@ pub struct ProgramClauseImplication<I: Interner> {
     pub conditions: Goals<I>,
 }
 
-#[derive(Clone, PartialEq, Eq, Hash, HasInterner)]
-pub enum ProgramClause<I: Interner> {
+#[derive(Clone, PartialEq, Eq, Hash, Fold, HasInterner)]
+pub enum ProgramClauseData<I: Interner> {
     Implies(ProgramClauseImplication<I>),
     ForAll(Binders<ProgramClauseImplication<I>>),
 }
@@ -1227,17 +1227,42 @@ impl<I: Interner> ProgramClauseImplication<I> {
     }
 }
 
-impl<I: Interner> ProgramClause<I> {
-    pub fn into_from_env_clause(self, interner: &I) -> ProgramClause<I> {
+impl<I: Interner> ProgramClauseData<I> {
+    pub fn into_from_env_clause(self, interner: &I) -> ProgramClauseData<I> {
         match self {
-            ProgramClause::Implies(implication) => {
-                ProgramClause::Implies(implication.into_from_env_clause(interner))
+            ProgramClauseData::Implies(implication) => {
+                ProgramClauseData::Implies(implication.into_from_env_clause(interner))
             }
-            ProgramClause::ForAll(binders_implication) => {
-                ProgramClause::ForAll(binders_implication.map(|i| i.into_from_env_clause(interner)))
+            ProgramClauseData::ForAll(binders_implication) => {
+                ProgramClauseData::ForAll(binders_implication.map(|i| i.into_from_env_clause(interner)))
             }
         }
     }
+
+    pub fn intern(self, interner: &I) -> ProgramClause<I> {
+        ProgramClause {
+            clause: interner.intern_program_clause(self),
+        }
+    }
+}
+
+#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord, HasInterner)]
+pub struct ProgramClause<I: Interner> {
+    clause: I::InternedProgramClause,
+}
+
+impl<I: Interner> ProgramClause<I> {
+    pub fn into_from_env_clause(self, interner: &I) -> ProgramClause<I> {
+        let program_clause_data = self.data(interner);
+        let new_clause = program_clause_data.clone().into_from_env_clause(interner);
+        ProgramClause {
+            clause: interner.intern_program_clause(new_clause),
+        }
+    }
+
+    pub fn data(&self, interner: &I) -> &ProgramClauseData<I> {
+        interner.program_clause_data(&self.clause)
+    }
 }
 
 /// Wraps a "canonicalized item". Items are canonicalized as follows:

chalk-ir/src/tls.rs

@@ -1,7 +1,7 @@
 use crate::interner::ChalkIr;
 use crate::{
     debug::SeparatorTraitRef, AliasTy, ApplicationTy, AssocTypeId, Goal, Goals, Lifetime,
-    Parameter, ProgramClauseImplication, StructId, Substitution, TraitId, Ty,
+    Parameter, ProgramClause, ProgramClauseImplication, StructId, Substitution, TraitId, Ty,
 };
 use std::cell::RefCell;
 use std::fmt;
@@ -68,6 +68,12 @@ pub trait DebugContext {
         fmt: &mut fmt::Formatter<'_>,
     ) -> Result<(), fmt::Error>;
 
+    fn debug_program_clause(
+        &self,
+        clause: &ProgramClause<ChalkIr>,
+        fmt: &mut fmt::Formatter<'_>,
+    ) -> Result<(), fmt::Error>;
+
     fn debug_application_ty(
         &self,
         application_ty: &ApplicationTy<ChalkIr>,

chalk-ir/src/zip.rs

@@ -309,7 +309,7 @@ enum_zip!(impl<I> for DomainGoal<I> {
     Compatible,
     DownstreamType
 });
-enum_zip!(impl<I> for ProgramClause<I> { Implies, ForAll });
+enum_zip!(impl<I> for ProgramClauseData<I> { Implies, ForAll });
 
 impl<I: Interner> Zip<I> for Substitution<I> {
     fn zip_with<'i, Z: Zipper<'i, I>>(zipper: &mut Z, a: &Self, b: &Self) -> Fallible<()>
@@ -396,3 +396,13 @@ impl<I: Interner> Zip<I> for Parameter<I> {
         Zip::zip_with(zipper, a.data(interner), b.data(interner))
     }
 }
+
+impl<I: Interner> Zip<I> for ProgramClause<I> {
+    fn zip_with<'i, Z: Zipper<'i, I>>(zipper: &mut Z, a: &Self, b: &Self) -> Fallible<()>
+    where
+        I: 'i,
+    {
+        let interner = zipper.interner();
+        Zip::zip_with(zipper, a.data(interner), b.data(interner))
+    }
+}