add missing fold methods

Author: basil-cow

chalk-ir/src/debug.rs

@@ -39,6 +39,13 @@ impl<I: Interner> Debug for Const<I> {
     }
 }
 
+impl<I: Interner> Debug for ConstEvaluated<I> {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
+        write!(fmt, "{:?}", self.interned) 
+    }
+}
+
+
 impl<I: Interner> Debug for Parameter<I> {
     fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error> {
         I::debug_parameter(self, fmt).unwrap_or_else(|| write!(fmt, "{:?}", self.interned))

chalk-ir/src/fold/shift.rs

@@ -93,6 +93,17 @@ impl<'i, I: Interner> Folder<'i, I> for Shifter<'i, I> {
         )
     }
 
+    fn fold_free_var_const(
+        &mut self,
+        bound_var: BoundVar,
+        outer_binder: DebruijnIndex,
+    ) -> Fallible<Const<I>> {
+        Ok(
+            ConstData::<I>::BoundVar(self.adjust(bound_var, outer_binder))
+                .intern(self.interner()),
+        )
+    }
+
     fn interner(&self) -> &'i I {
         self.interner
     }
@@ -153,6 +164,17 @@ impl<'i, I: Interner> Folder<'i, I> for DownShifter<'i, I> {
         )
     }
 
+    fn fold_free_var_const(
+        &mut self,
+        bound_var: BoundVar,
+        outer_binder: DebruijnIndex,
+    ) -> Fallible<Const<I>> {
+        Ok(
+            ConstData::<I>::BoundVar(self.adjust(bound_var, outer_binder)?)
+                .intern(self.interner()),
+        )
+    }
+
     fn interner(&self) -> &'i I {
         self.interner
     }

chalk-ir/src/fold/subst.rs

@@ -87,6 +87,27 @@ impl<'i, I: Interner> Folder<'i, I> for Subst<'_, 'i, I> {
         }
     }
 
+    fn fold_free_var_const(
+        &mut self,
+        bound_var: BoundVar,
+        outer_binder: DebruijnIndex,
+    ) -> Fallible<Const<I>> {
+        // see comment in `fold_free_var_ty`
+
+        if let Some(index) = bound_var.index_if_innermost() {
+            match self.parameters[index].data(self.interner()) {
+                ParameterKind::Const(c) => Ok(c.shifted_in_from(self.interner(), outer_binder)),
+                _ => panic!("mismatched kinds in substitution"),
+            }
+        } else {
+            Ok(bound_var
+                .shifted_out()
+                .unwrap()
+                .shifted_in_from(outer_binder)
+                .to_const(self.interner()))
+        }
+    }
+
     fn interner(&self) -> &'i I {
         self.interner
     }

chalk-ir/src/lib.rs

@@ -336,6 +336,10 @@ impl BoundVar {
         LifetimeData::<I>::BoundVar(self).intern(interner)
     }
 
+    pub fn to_const<I: Interner>(self, interner: &I) -> Const<I> {
+        ConstData::<I>::BoundVar(self).intern(interner)
+    }
+
     /// True if this variable is bound within the `amount` innermost binders.
     pub fn bound_within(self, outer_binder: DebruijnIndex) -> bool {
         self.debruijn.within(outer_binder)
@@ -653,7 +657,7 @@ impl<I: Interner> ConstData<I> {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, HasInterner)]
+#[derive(Clone, PartialEq, Eq, Hash, PartialOrd, Ord, HasInterner)]
 pub struct ConstEvaluated<I: Interner> {
     pub interned: I::InternedConstEvaluated,
 }
@@ -888,6 +892,10 @@ impl<I: Interner> Parameter<I> {
         self.as_ref(interner).lifetime().unwrap()
     }
 
+    pub fn assert_const_ref(&self, interner: &I) -> &Const<I> {
+        self.as_ref(interner).constant().unwrap()
+    }
+
     pub fn as_ref(&self, interner: &I) -> ParameterKind<&Ty<I>, &Lifetime<I>, &Const<I>> {
         match self.data(interner) {
             ParameterKind::Ty(t) => ParameterKind::Ty(t),
@@ -1972,6 +1980,17 @@ impl<'i, I: Interner> Folder<'i, I> for &SubstFolder<'i, I> {
         Ok(l.shifted_in_from(self.interner(), outer_binder))
     }
 
+    fn fold_free_var_const(
+        &mut self,
+        bound_var: BoundVar,
+        outer_binder: DebruijnIndex,
+    ) -> Fallible<Const<I>> {
+        assert_eq!(bound_var.debruijn, DebruijnIndex::INNERMOST);
+        let c = self.at(bound_var.index);
+        let c = c.assert_const_ref(self.interner());
+        Ok(c.shifted_in_from(self.interner(), outer_binder))
+    }
+
     fn interner(&self) -> &'i I {
         self.interner
     }

chalk-parse/src/parser.lalrpop

@@ -390,7 +390,7 @@ LifetimeId: Identifier = {
 };
 
 ConstId: Identifier = {
-    <l:@L> "#" <s:r"([A-Za-z]|_)([A-Za-z0-9]|_)*"> <r:@R> => Identifier {
+    <l:@L> "$" <s:r"([A-Za-z]|_)([A-Za-z0-9]|_)*"> <r:@R> => Identifier {
         str: intern(s),
         span: Span::new(l, r),
     }

chalk-solve/src/infer/canonicalize.rs

@@ -124,6 +124,16 @@ where
         Ok(universe.to_lifetime(interner))
     }
 
+    fn fold_free_placeholder_const(
+        &mut self,
+        universe: PlaceholderIndex,
+        _outer_binder: DebruijnIndex,
+    ) -> Fallible<Const<I>> {
+        let interner = self.interner;
+        self.max_universe = max(self.max_universe, universe.ui);
+        Ok(universe.to_const(interner))
+    }
+
     fn forbid_free_vars(&self) -> bool {
         true
     }
@@ -190,6 +200,36 @@ where
         }
     }
 
+    fn fold_inference_const(
+        &mut self,
+        var: InferenceVar,
+        outer_binder: DebruijnIndex,
+    ) -> Fallible<Const<I>> {
+        debug_heading!(
+            "fold_inference_const(depth={:?}, outer_binder={:?})",
+            var,
+            outer_binder
+        );
+        let interner = self.interner;
+        let var = EnaVariable::from(var);
+        match self.table.probe_const_var(interner, var) {
+            Some(c) => {
+                debug!("bound to {:?}", c);
+                Ok(c.fold_with(self, DebruijnIndex::INNERMOST)?
+                    .shifted_in_from(interner, outer_binder))
+            }
+            None => {
+                let free_var = ParameterKind::Const(self.table.unify.find(var));
+                let bound_var = BoundVar::new(DebruijnIndex::INNERMOST, self.add(free_var));
+                debug!("not yet unified: position={:?}", bound_var);
+                Ok(
+                    ConstData::BoundVar(bound_var.shifted_in_from(outer_binder))
+                        .intern(interner),
+                )
+            }
+        }
+    }
+
     fn interner(&self) -> &'i I {
         self.interner
     }

tests/test/misc.rs

@@ -507,21 +507,3 @@ fn non_enumerable_traits_reorder() {
         }
     }
 }
-
-#[test]
-fn my_test() {
-    test! {
-        program {
-            struct Foo<#N> {}
-            struct TyFoo<T> {}
-        } 
-
-        goal {
-            exists<#N> {
-                Foo<#N> = Foo<45>
-            }
-        } yields {
-            ""
-        }
-    }
-}