move universes from environment into the inference table

src/bin/chalki.rs

@@ -1,9 +1,9 @@
 #![feature(match_default_bindings)]
 
-extern crate rustyline;
-extern crate chalk_parse;
 extern crate chalk;
+extern crate chalk_parse;
 extern crate docopt;
+extern crate rustyline;
 
 #[macro_use]
 extern crate serde_derive;
@@ -136,7 +136,8 @@ fn run() -> Result<()> {
 
 /// Repeatedly calls `f`, passing in each line, using the given promt, until EOF is received
 fn readline_loop<F>(rl: &mut rustyline::Editor<()>, prompt: &str, mut f: F) -> Result<()>
-    where F: FnMut(&mut rustyline::Editor<()>, &str)
+where
+    F: FnMut(&mut rustyline::Editor<()>, &str),
 {
     loop {
         match rl.readline(prompt) {
@@ -153,11 +154,12 @@ fn readline_loop<F>(rl: &mut rustyline::Editor<()>, prompt: &str, mut f: F) -> R
 }
 
 /// Process a single command
-fn process(args: &Args,
-           command: &str,
-           rl: &mut rustyline::Editor<()>,
-           prog: &mut Option<Program>)
-           -> Result<()> {
+fn process(
+    args: &Args,
+    command: &str,
+    rl: &mut rustyline::Editor<()>,
+    prog: &mut Option<Program>,
+) -> Result<()> {
     if command == "help" {
         help()
     } else if command == "program" {
@@ -211,24 +213,26 @@ fn goal(args: &Args, text: &str, prog: &Program) -> Result<()> {
     let peeled_goal = goal.into_peeled_goal();
     if args.flag_slg && args.flag_all_answers {
         match slg::solve_root_goal(args.flag_overflow_depth, &prog.env, &peeled_goal) {
-            Ok(slg::Answers { answers }) => {
-                if answers.is_empty() {
-                    println!("No answers found.");
-                } else {
-                    println!("{} answer(s) found:", answers.len());
-                    for answer in &answers {
-                        println!("- {}{}",
-                                 answer.subst,
-                                 if answer.ambiguous { " [ambiguous]" } else { "" });
-                    }
+            Ok(slg::Answers { answers }) => if answers.is_empty() {
+                println!("No answers found.");
+            } else {
+                println!("{} answer(s) found:", answers.len());
+                for answer in &answers {
+                    println!(
+                        "- {}{}",
+                        answer.subst,
+                        if answer.ambiguous { " [ambiguous]" } else { "" }
+                    );
                 }
-            }
+            },
             Err(error) => {
                 println!("exploration error: {:?}\n", error);
             }
         }
     } else {
-        match args.solver_choice().solve_root_goal(&prog.env, &peeled_goal) {
+        match args.solver_choice()
+            .solve_root_goal(&prog.env, &peeled_goal)
+        {
             Ok(Some(v)) => println!("{}\n", v),
             Ok(None) => println!("No possible solution.\n"),
             Err(e) => println!("Solver failed: {}", e),

src/cast.rs

@@ -183,7 +183,8 @@ map_impl!(impl[T: Cast<U>, U] Cast<InEnvironment<U>> for InEnvironment<T>);
 map_impl!(impl[T: Cast<U>, U, E] Cast<Result<U, E>> for Result<T, E>);
 
 impl<T, U> Cast<Canonical<U>> for Canonical<T>
-    where T: Cast<U>
+where
+    T: Cast<U>,
 {
     fn cast(self) -> Canonical<U> {
         // Subtle point: It should be ok to re-use the binders here,
@@ -192,13 +193,14 @@ impl<T, U> Cast<Canonical<U>> for Canonical<T>
         // with. It just introduces new wrapper types.
         Canonical {
             value: self.value.cast(),
-            binders: self.binders
+            binders: self.binders,
         }
     }
 }
 
 impl<T, U> Cast<Vec<U>> for Vec<T>
-    where T: Cast<U>
+where
+    T: Cast<U>,
 {
     fn cast(self) -> Vec<U> {
         self.into_iter().casted().collect()
@@ -210,7 +212,10 @@ pub struct Casted<I, U> {
     _cast: PhantomData<U>,
 }
 
-impl<I: Iterator, U> Iterator for Casted<I, U> where I::Item: Cast<U> {
+impl<I: Iterator, U> Iterator for Casted<I, U>
+where
+    I::Item: Cast<U>,
+{
     type Item = U;
 
     fn next(&mut self) -> Option<Self::Item> {

src/coherence/mod.rs

@@ -1,7 +1,7 @@
 use petgraph::prelude::*;
 
 use errors::Result;
-use ir::{self, Program, ItemId};
+use ir::{self, ItemId, Program};
 use solve::SolverChoice;
 use std::sync::Arc;
 
@@ -24,7 +24,10 @@ impl Program {
     }
 
     // Build the forest of specialization relationships.
-    fn build_specialization_forest(&self, solver_choice: SolverChoice) -> Result<Graph<ItemId, ()>> {
+    fn build_specialization_forest(
+        &self,
+        solver_choice: SolverChoice,
+    ) -> Result<Graph<ItemId, ()>> {
         // The forest is returned as a graph but built as a GraphMap; this is
         // so that we never add multiple nodes with the same ItemId.
         let mut forest = DiGraphMap::new();
@@ -41,11 +44,14 @@ impl Program {
 
     // Recursively set priorities for those node and all of its children.
     fn set_priorities(&mut self, idx: NodeIndex, forest: &Graph<ItemId, ()>, p: usize) {
-
         // Get the impl datum recorded at this node and reset its priority
         {
-            let impl_id = forest.node_weight(idx).expect("index should be a valid index into graph");
-            let impl_datum = self.impl_data.get_mut(impl_id).expect("node should be valid impl id");
+            let impl_id = forest
+                .node_weight(idx)
+                .expect("index should be a valid index into graph");
+            let impl_datum = self.impl_data
+                .get_mut(impl_id)
+                .expect("node should be valid impl id");
             impl_datum.binders.value.specialization_priority = p;
         }
 

src/errors.rs

@@ -40,4 +40,3 @@ error_chain! {
         }
     }
 }
-

src/fold/mod.rs

@@ -6,13 +6,13 @@ use ir::*;
 use std::fmt::Debug;
 use std::sync::Arc;
 
-mod instantiate;
 mod shifted;
 mod shifter;
+mod subst;
 
 pub use self::shifted::Shifted;
 pub use self::shifter::Shifter;
-pub use self::instantiate::Subst;
+pub use self::subst::Subst;
 
 /// A "folder" is a transformer that can be used to make a copy of
 /// some term -- that is, some bit of IR, such as a `Goal` -- with
@@ -105,7 +105,11 @@ pub trait ExistentialFolder {
     fn fold_free_existential_ty(&mut self, depth: usize, binders: usize) -> Fallible<Ty>;
 
     /// As `fold_free_existential_ty`, but for lifetimes.
-    fn fold_free_existential_lifetime(&mut self, depth: usize, binders: usize) -> Fallible<Lifetime>;
+    fn fold_free_existential_lifetime(
+        &mut self,
+        depth: usize,
+        binders: usize,
+    ) -> Fallible<Lifetime>;
 }
 
 /// A convenience trait. If you implement this, you get an
@@ -118,7 +122,11 @@ impl<T: IdentityExistentialFolder> ExistentialFolder for T {
         Ok(Ty::Var(depth + binders))
     }
 
-    fn fold_free_existential_lifetime(&mut self, depth: usize, binders: usize) -> Fallible<Lifetime> {
+    fn fold_free_existential_lifetime(
+        &mut self,
+        depth: usize,
+        binders: usize,
+    ) -> Fallible<Lifetime> {
         Ok(Lifetime::Var(depth + binders))
     }
 }
@@ -268,7 +276,9 @@ pub fn super_fold_ty(folder: &mut Folder, ty: &Ty, binders: usize) -> Fallible<T
             }
         }
         Ty::Projection(ref proj) => Ok(Ty::Projection(proj.fold_with(folder, binders)?)),
-        Ty::UnselectedProjection(ref proj) => Ok(Ty::UnselectedProjection(proj.fold_with(folder, binders)?)),
+        Ty::UnselectedProjection(ref proj) => {
+            Ok(Ty::UnselectedProjection(proj.fold_with(folder, binders)?))
+        }
         Ty::ForAll(ref quantified_ty) => Ok(Ty::ForAll(quantified_ty.fold_with(folder, binders)?)),
     }
 }
@@ -349,13 +359,12 @@ impl Fold for Substitution {
     type Result = Substitution;
     fn fold_with(&self, folder: &mut Folder, binders: usize) -> Fallible<Self::Result> {
         // Do not fold the keys of the substitution, just the values.
-        let parameters =
-            self.parameters.iter()
-                           .map(|(&key, value)| {
-                               value.fold_with(folder, binders)
-                                    .map(|value| (key, value))
-                           })
-                           .collect::<Fallible<_>>()?;
+        let parameters = self.parameters
+            .iter()
+            .map(|(&key, value)| {
+                value.fold_with(folder, binders).map(|value| (key, value))
+            })
+            .collect::<Fallible<_>>()?;
         Ok(Substitution { parameters })
     }
 }
@@ -433,7 +442,7 @@ struct_fold!(ProjectionTy {
 });
 struct_fold!(UnselectedProjectionTy {
     type_name,
-    parameters
+    parameters,
 });
 struct_fold!(TraitRef {
     trait_id,
@@ -446,7 +455,7 @@ struct_fold!(AssociatedTyValue {
     value,
 });
 struct_fold!(AssociatedTyValueBound { ty, where_clauses });
-struct_fold!(Environment { universe, clauses });
+struct_fold!(Environment { clauses });
 struct_fold!(InEnvironment[F] { environment, goal } where F: Fold);
 struct_fold!(EqGoal { a, b });
 struct_fold!(ProgramClauseImplication {

src/fold/shifted.rs

@@ -36,6 +36,3 @@ impl<T: Fold<Result = T>> Fold for Shifted<T> {
         value.fold_with(folder, binders)
     }
 }
-
-
-