Move generalizer to its own module

Author: flodiebold

chalk-solve/src/clauses.rs

@@ -13,6 +13,7 @@ use rustc_hash::FxHashSet;
 pub mod builder;
 mod builtin_traits;
 mod env_elaborator;
+mod generalize;
 pub mod program_clauses;
 
 /// For auto-traits, we generate a default rule for every struct,
@@ -436,80 +437,3 @@ fn program_clauses_for_env<'db, I: Interner>(
 
     clauses.extend(closure.drain())
 }
-
-mod generalize {
-    use chalk_engine::fallible::Fallible;
-    use chalk_ir::{
-        fold::{Fold, Folder},
-        interner::Interner,
-        Binders, BoundVar, DebruijnIndex, Lifetime, LifetimeData, ParameterKind, Ty, TyData,
-    };
-    use std::collections::HashMap;
-
-    pub struct Generalize<'i, I: Interner> {
-        binders: Vec<ParameterKind<()>>,
-        mapping: HashMap<BoundVar, usize>,
-        interner: &'i I,
-    }
-
-    impl<I: Interner> Generalize<'_, I> {
-        pub fn apply<T: Fold<I, I>>(interner: &I, value: &T) -> Binders<T::Result> {
-            let mut generalize = Generalize {
-                binders: Vec::new(),
-                mapping: HashMap::new(),
-                interner,
-            };
-            let value = value
-                .fold_with(&mut generalize, DebruijnIndex::INNERMOST)
-                .unwrap();
-            Binders {
-                binders: generalize.binders,
-                value,
-            }
-        }
-    }
-
-    impl<'i, I: Interner> Folder<'i, I> for Generalize<'i, I> {
-        fn as_dyn(&mut self) -> &mut dyn Folder<'i, I> {
-            self
-        }
-
-        fn fold_free_var_ty(
-            &mut self,
-            bound_var: BoundVar,
-            outer_binder: DebruijnIndex,
-        ) -> Fallible<Ty<I>> {
-            let binder_vec = &mut self.binders;
-            let new_index = self.mapping.entry(bound_var).or_insert_with(|| {
-                let i = binder_vec.len();
-                binder_vec.push(ParameterKind::Ty(()));
-                i
-            });
-            let new_var = BoundVar::new(outer_binder, *new_index);
-            Ok(TyData::BoundVar(new_var).intern(self.interner()))
-        }
-
-        fn fold_free_var_lifetime(
-            &mut self,
-            bound_var: BoundVar,
-            outer_binder: DebruijnIndex,
-        ) -> Fallible<Lifetime<I>> {
-            let binder_vec = &mut self.binders;
-            let new_index = self.mapping.entry(bound_var).or_insert_with(|| {
-                let i = binder_vec.len();
-                binder_vec.push(ParameterKind::Ty(()));
-                i
-            });
-            let new_var = BoundVar::new(outer_binder, *new_index);
-            Ok(LifetimeData::BoundVar(new_var).intern(self.interner()))
-        }
-
-        fn interner(&self) -> &'i I {
-            self.interner
-        }
-
-        fn target_interner(&self) -> &'i I {
-            self.interner
-        }
-    }
-}

chalk-solve/src/clauses/generalize.rs

@@ -0,0 +1,80 @@
+//! This gets rid of free variables in a type by replacing them by fresh bound
+//! ones. We use this when building clauses that contain types passed to
+//! `program_clauses`; these may contain variables, and just copying those
+//! variables verbatim leads to problems. Instead, we return a slightly more
+//! general program clause, with new variables in those places.
+
+use chalk_engine::fallible::Fallible;
+use chalk_ir::{
+    fold::{Fold, Folder},
+    interner::Interner,
+    Binders, BoundVar, DebruijnIndex, Lifetime, LifetimeData, ParameterKind, Ty, TyData,
+};
+use std::collections::HashMap;
+
+pub struct Generalize<'i, I: Interner> {
+    binders: Vec<ParameterKind<()>>,
+    mapping: HashMap<BoundVar, usize>,
+    interner: &'i I,
+}
+
+impl<I: Interner> Generalize<'_, I> {
+    pub fn apply<T: Fold<I, I>>(interner: &I, value: &T) -> Binders<T::Result> {
+        let mut generalize = Generalize {
+            binders: Vec::new(),
+            mapping: HashMap::new(),
+            interner,
+        };
+        let value = value
+            .fold_with(&mut generalize, DebruijnIndex::INNERMOST)
+            .unwrap();
+        Binders {
+            binders: generalize.binders,
+            value,
+        }
+    }
+}
+
+impl<'i, I: Interner> Folder<'i, I> for Generalize<'i, I> {
+    fn as_dyn(&mut self) -> &mut dyn Folder<'i, I> {
+        self
+    }
+
+    fn fold_free_var_ty(
+        &mut self,
+        bound_var: BoundVar,
+        outer_binder: DebruijnIndex,
+    ) -> Fallible<Ty<I>> {
+        let binder_vec = &mut self.binders;
+        let new_index = self.mapping.entry(bound_var).or_insert_with(|| {
+            let i = binder_vec.len();
+            binder_vec.push(ParameterKind::Ty(()));
+            i
+        });
+        let new_var = BoundVar::new(outer_binder, *new_index);
+        Ok(TyData::BoundVar(new_var).intern(self.interner()))
+    }
+
+    fn fold_free_var_lifetime(
+        &mut self,
+        bound_var: BoundVar,
+        outer_binder: DebruijnIndex,
+    ) -> Fallible<Lifetime<I>> {
+        let binder_vec = &mut self.binders;
+        let new_index = self.mapping.entry(bound_var).or_insert_with(|| {
+            let i = binder_vec.len();
+            binder_vec.push(ParameterKind::Ty(()));
+            i
+        });
+        let new_var = BoundVar::new(outer_binder, *new_index);
+        Ok(LifetimeData::BoundVar(new_var).intern(self.interner()))
+    }
+
+    fn interner(&self) -> &'i I {
+        self.interner
+    }
+
+    fn target_interner(&self) -> &'i I {
+        self.interner
+    }
+}