make TyInferenceValue and KrateInferenceValue work same way

Author: nikomatsakis

chalk-rust/src/solve/infer/krate_var.rs

@@ -3,17 +3,15 @@ use errors::*;
 use ir::*;
 use std::sync::Arc;
 
-mod krate_var;
 mod instantiate;
 mod lifetime_var;
 mod query;
 mod unify;
-mod ty_var;
+mod var;
 #[cfg(test)] mod test;
 
 pub use self::unify::UnificationResult;
-use self::ty_var::{TyInferenceVariable, TyInferenceValue};
-use self::krate_var::{KrateInferenceVariable, KrateInferenceValue};
+use self::var::{TyInferenceVariable, KrateInferenceVariable, InferenceValue};
 use self::lifetime_var::LifetimeInferenceVariable;
 
 #[derive(Clone)]
@@ -22,6 +20,7 @@ pub struct InferenceTable {
     ty_values: Vec<Arc<Ty>>,
 
     krate_unify: ena::UnificationTable<KrateInferenceVariable>,
+    krate_values: Vec<Krate>,
 
     /// Unlike normal variables, we don't unify lifetime variables.
     /// Instead, we just keep track of the universe in which they were
@@ -40,28 +39,13 @@ pub type ParameterInferenceVariable = ParameterKind<TyInferenceVariable,
                                                     LifetimeInferenceVariable,
                                                     KrateInferenceVariable>;
 
-/// An index into the `InferenceTable.values` vector.
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub struct ValueIndex {
-    index: u32
-}
-
-impl ValueIndex {
-    pub fn new(value: usize) -> ValueIndex {
-        ValueIndex { index: value as u32 }
-    }
-
-    pub fn as_usize(&self) -> usize {
-        self.index as usize
-    }
-}
-
 impl InferenceTable {
     pub fn new() -> Self {
         InferenceTable {
             ty_unify: ena::UnificationTable::new(),
             krate_unify: ena::UnificationTable::new(),
             ty_values: vec![],
+            krate_values: vec![],
             lifetime_vars: vec![],
         }
     }
@@ -75,7 +59,7 @@ impl InferenceTable {
     }
 
     pub fn new_variable(&mut self, ui: UniverseIndex) -> TyInferenceVariable {
-        self.ty_unify.new_key(TyInferenceValue::Unbound(ui))
+        self.ty_unify.new_key(InferenceValue::Unbound(ui))
     }
 
     pub fn new_lifetime_variable(&mut self, ui: UniverseIndex) -> LifetimeInferenceVariable {
@@ -85,7 +69,7 @@ impl InferenceTable {
     }
 
     pub fn new_krate_variable(&mut self, ui: UniverseIndex) -> KrateInferenceVariable {
-        self.krate_unify.new_key(KrateInferenceValue::Unbound(ui))
+        self.krate_unify.new_key(InferenceValue::Unbound(ui))
     }
 
     pub fn new_parameter_variable(&mut self, ui: ParameterKind<UniverseIndex>)
@@ -141,8 +125,8 @@ impl InferenceTable {
         leaf.inference_var()
             .and_then(|var| {
                 match self.ty_unify.probe_value(var) {
-                    TyInferenceValue::Unbound(_) => None,
-                    TyInferenceValue::Bound(val) => Some(self.ty_values[val.as_usize()].clone()),
+                    InferenceValue::Unbound(_) => None,
+                    InferenceValue::Bound(val) => Some(self.ty_values[val.as_usize()].clone()),
                 }
             })
     }
@@ -156,15 +140,15 @@ impl InferenceTable {
 
     fn probe_var(&mut self, var: TyInferenceVariable) -> Option<Arc<Ty>> {
         match self.ty_unify.probe_value(var) {
-            TyInferenceValue::Unbound(_) => None,
-            TyInferenceValue::Bound(val) => Some(self.ty_values[val.as_usize()].clone()),
+            InferenceValue::Unbound(_) => None,
+            InferenceValue::Bound(val) => Some(self.ty_values[val.as_usize()].clone()),
         }
     }
 
     fn probe_krate_var(&mut self, var: KrateInferenceVariable) -> Option<Krate> {
         match self.krate_unify.probe_value(var) {
-            KrateInferenceValue::Unbound(_) => None,
-            KrateInferenceValue::Bound(id) => Some(Krate::Id(id)),
+            InferenceValue::Unbound(_) => None,
+            InferenceValue::Bound(val) => Some(self.krate_values[val.as_usize()]),
         }
     }
 }

chalk-rust/src/solve/infer/mod.rs

@@ -4,8 +4,7 @@ use ir::*;
 
 use super::{InferenceTable, TyInferenceVariable,
             KrateInferenceVariable, LifetimeInferenceVariable, ParameterInferenceVariable};
-use super::ty_var::TyInferenceValue;
-use super::krate_var::KrateInferenceValue;
+use super::var::InferenceValue;
 
 impl InferenceTable {
     /// Given a value `value` with variables in it, replaces those
@@ -49,8 +48,8 @@ impl<'q> Querifier<'q> {
                      ParameterKind::Ty(v) => {
                          debug_assert!(table.ty_unify.find(v) == v);
                          match table.ty_unify.probe_value(v) {
-                             TyInferenceValue::Unbound(ui) => ParameterKind::Ty(ui),
-                             TyInferenceValue::Bound(_) => panic!("free var now bound"),
+                             InferenceValue::Unbound(ui) => ParameterKind::Ty(ui),
+                             InferenceValue::Bound(_) => panic!("free var now bound"),
                          }
                      },
 
@@ -60,8 +59,8 @@ impl<'q> Querifier<'q> {
 
                      ParameterKind::Krate(c) => {
                          match table.krate_unify.probe_value(c) {
-                             KrateInferenceValue::Unbound(ui) => ParameterKind::Krate(ui),
-                             KrateInferenceValue::Bound(_) => panic!("free var now bound")
+                             InferenceValue::Unbound(ui) => ParameterKind::Krate(ui),
+                             InferenceValue::Bound(_) => panic!("free var now bound")
                          }
                      },
                  })

chalk-rust/src/solve/infer/query.rs

@@ -1,15 +1,12 @@
 use cast::Cast;
-use ena::unify::UnifyValue;
-use errors::*;
 use ir::*;
 use solve::environment::{Environment, InEnvironment};
 use std::fmt::Debug;
 use std::sync::Arc;
 use zip::{Zip, Zipper};
 
-use super::{InferenceSnapshot, InferenceTable};
-use super::ty_var::{TyInferenceVariable, TyInferenceValue, ValueIndex};
-use super::krate_var::{KrateInferenceVariable, KrateInferenceValue};
+use super::*;
+use super::var::*;
 
 impl InferenceTable {
     pub fn unify<T>(&mut self,
@@ -204,22 +201,29 @@ impl<'t> Unifier<'t> {
         // this variable was created -- though it may change over time
         // as the variable is unified.
         let universe_index = match self.table.ty_unify.probe_value(var) {
-            TyInferenceValue::Unbound(ui) => ui,
-            TyInferenceValue::Bound(_) => panic!("`unify_var_apply` invoked on bound var"),
+            InferenceValue::Unbound(ui) => ui,
+            InferenceValue::Bound(_) => panic!("`unify_var_apply` invoked on bound var"),
         };
 
         OccursCheck::new(self, var, universe_index).check_ty(ty)?;
 
         let value_index = ValueIndex::new(self.table.ty_values.len());
         self.table.ty_values.push(Arc::new(ty.clone()));
-        self.table.ty_unify.unify_var_value(var, TyInferenceValue::Bound(value_index)).unwrap();
+        self.table.ty_unify.unify_var_value(var, InferenceValue::Bound(value_index)).unwrap();
         debug!("unify_var_ty: var {:?} set to {:?}", var, ty);
 
         Ok(())
     }
 
     fn unify_krate_krate(&mut self, a: &Krate, b: &Krate) -> Result<()> {
+        if let Some(n_a) = self.table.normalize_krate(a) {
+            return self.unify_krate_krate(&n_a, b);
+        } else if let Some(n_b) = self.table.normalize_krate(b) {
+            return self.unify_krate_krate(a, &n_b);
+        }
+
         debug_heading!("unify_krate_krate({:?}, {:?})", a, b);
+
         let result = match (a, b) {
             (&Krate::Var(depth_a), &Krate::Var(depth_b)) => {
                 let var_a = KrateInferenceVariable::from_depth(depth_a);
@@ -230,14 +234,17 @@ impl<'t> Unifier<'t> {
             (&Krate::Var(depth), &Krate::Id(id)) |
             (&Krate::Id(id), &Krate::Var(depth)) => {
                 let var = KrateInferenceVariable::from_depth(depth);
-                let value = KrateInferenceValue::Bound(id);
-                self.table.krate_unify.unify_var_value(var, value)
+                let value_index = ValueIndex::new(self.table.krate_values.len());
+                self.table.krate_values.push(Krate::Id(id));
+                self.table.krate_unify.unify_var_value(var, InferenceValue::Bound(value_index))
             }
 
             (&Krate::Id(a_id), &Krate::Id(b_id)) => {
-                let a_value = KrateInferenceValue::Bound(a_id);
-                let b_value = KrateInferenceValue::Bound(b_id);
-                KrateInferenceValue::unify_values(&a_value, &b_value).map(|_| ())
+                if a_id == b_id {
+                    Ok(())
+                } else {
+                    bail!("krate `{:?}` not equal to `{:?}`", a_id, b_id)
+                }
             }
         };
 
@@ -341,8 +348,8 @@ impl<'u, 't> OccursCheck<'u, 't> {
             Ty::Var(depth) => {
                 let v = TyInferenceVariable::from_depth(depth - self.binders);
                 let ui = match self.unifier.table.ty_unify.probe_value(v) {
-                    TyInferenceValue::Unbound(ui) => ui,
-                    TyInferenceValue::Bound(_) => {
+                    InferenceValue::Unbound(ui) => ui,
+                    InferenceValue::Bound(_) => {
                         unreachable!("expected `parameter` to be normalized")
                     }
                 };
@@ -361,7 +368,7 @@ impl<'u, 't> OccursCheck<'u, 't> {
                     self.unifier
                         .table
                         .ty_unify
-                        .unify_var_value(v, TyInferenceValue::Unbound(self.universe_index))
+                        .unify_var_value(v, InferenceValue::Unbound(self.universe_index))
                         .unwrap();
                 }
             }