rename the fields in infer/mod to make ty less special

nikomatsakis · nikomatsakis · commit 39cd395dcc1e · 2017-02-24T17:53:03.000-05:00
Also add krates to the snapshots.
diff --git a/chalk-rust/src/solve/infer/mod.rs b/chalk-rust/src/solve/infer/mod.rs
@@ -18,8 +18,8 @@ use self::lifetime_var::LifetimeInferenceVariable;
 
 #[derive(Clone)]
 pub struct InferenceTable {
-    unify: ena::UnificationTable<TyInferenceVariable>,
-    values: Vec<Arc<Ty>>,
+    ty_unify: ena::UnificationTable<TyInferenceVariable>,
+    ty_values: Vec<Arc<Ty>>,
 
     krate_unify: ena::UnificationTable<KrateInferenceVariable>,
 
@@ -30,8 +30,10 @@ pub struct InferenceTable {
 }
 
 pub struct InferenceSnapshot {
-    unify_snapshot: ena::Snapshot<TyInferenceVariable>,
-    values_len: usize,
+    ty_unify_snapshot: ena::Snapshot<TyInferenceVariable>,
+    ty_values_len: usize,
+
+    krate_unify_snapshot: ena::Snapshot<KrateInferenceVariable>,
 }
 
 pub type ParameterInferenceVariable = ParameterKind<TyInferenceVariable,
@@ -41,9 +43,9 @@ pub type ParameterInferenceVariable = ParameterKind<TyInferenceVariable,
 impl InferenceTable {
     pub fn new() -> Self {
         InferenceTable {
-            unify: ena::UnificationTable::new(),
+            ty_unify: ena::UnificationTable::new(),
             krate_unify: ena::UnificationTable::new(),
-            values: vec![],
+            ty_values: vec![],
             lifetime_vars: vec![],
         }
     }
@@ -57,7 +59,7 @@ impl InferenceTable {
     }
 
     pub fn new_variable(&mut self, ui: UniverseIndex) -> TyInferenceVariable {
-        self.unify.new_key(TyInferenceValue::Unbound(ui))
+        self.ty_unify.new_key(TyInferenceValue::Unbound(ui))
     }
 
     pub fn new_lifetime_variable(&mut self, ui: UniverseIndex) -> LifetimeInferenceVariable {
@@ -84,20 +86,22 @@ impl InferenceTable {
     }
 
     pub fn snapshot(&mut self) -> InferenceSnapshot {
-        let unify_snapshot = self.unify.snapshot();
+        let ty_unify_snapshot = self.ty_unify.snapshot();
+        let krate_unify_snapshot = self.krate_unify.snapshot();
         InferenceSnapshot {
-            unify_snapshot: unify_snapshot,
-            values_len: self.values.len(),
+            ty_unify_snapshot,
+            krate_unify_snapshot,
+            ty_values_len: self.ty_values.len(),
         }
     }
 
     pub fn rollback_to(&mut self, snapshot: InferenceSnapshot) {
-        self.unify.rollback_to(snapshot.unify_snapshot);
-        self.values.truncate(snapshot.values_len);
+        self.ty_unify.rollback_to(snapshot.ty_unify_snapshot);
+        self.ty_values.truncate(snapshot.ty_values_len);
     }
 
     fn commit(&mut self, snapshot: InferenceSnapshot) {
-        self.unify.commit(snapshot.unify_snapshot);
+        self.ty_unify.commit(snapshot.ty_unify_snapshot);
     }
 
     fn commit_if_ok<F, R>(&mut self, op: F) -> Result<R>
@@ -120,9 +124,9 @@ impl InferenceTable {
     fn normalize_shallow(&mut self, leaf: &Ty) -> Option<Arc<Ty>> {
         leaf.inference_var()
             .and_then(|var| {
-                match self.unify.probe_value(var) {
+                match self.ty_unify.probe_value(var) {
                     TyInferenceValue::Unbound(_) => None,
-                    TyInferenceValue::Bound(val) => Some(self.values[val.as_usize()].clone()),
+                    TyInferenceValue::Bound(val) => Some(self.ty_values[val.as_usize()].clone()),
                 }
             })
     }
@@ -135,9 +139,9 @@ impl InferenceTable {
     }
 
     fn probe_var(&mut self, var: TyInferenceVariable) -> Option<Arc<Ty>> {
-        match self.unify.probe_value(var) {
+        match self.ty_unify.probe_value(var) {
             TyInferenceValue::Unbound(_) => None,
-            TyInferenceValue::Bound(val) => Some(self.values[val.as_usize()].clone()),
+            TyInferenceValue::Bound(val) => Some(self.ty_values[val.as_usize()].clone()),
         }
     }
 
diff --git a/chalk-rust/src/solve/infer/query.rs b/chalk-rust/src/solve/infer/query.rs
@@ -47,8 +47,8 @@ impl<'q> Querifier<'q> {
         free_vars.into_iter()
                  .map(|p_v| match p_v {
                      ParameterKind::Ty(v) => {
-                         debug_assert!(table.unify.find(v) == v);
-                         match table.unify.probe_value(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"),
                          }
@@ -97,7 +97,7 @@ impl<'q> Folder for Querifier<'q> {
                 // canonical index `root_var` in the union-find table,
                 // and then map `root_var` to a fresh index that is
                 // unique to this quantification.
-                let free_var = ParameterKind::Ty(self.table.unify.find(var));
+                let free_var = ParameterKind::Ty(self.table.ty_unify.find(var));
                 let position = self.add(free_var) + binders;
                 Ok(TyInferenceVariable::from_depth(position).to_ty())
             }
diff --git a/chalk-rust/src/solve/infer/unify.rs b/chalk-rust/src/solve/infer/unify.rs
@@ -87,7 +87,7 @@ impl<'t> Unifier<'t> {
                 let var2 = TyInferenceVariable::from_depth(depth2);
                 debug!("unify_ty_ty: unify_var_var({:?}, {:?})", var1, var2);
                 Ok(self.table
-                    .unify
+                    .ty_unify
                     .unify_var_var(var1, var2)
                     .expect("unification of two unbound variables cannot fail"))
             }
@@ -203,16 +203,16 @@ impl<'t> Unifier<'t> {
         // `forall` binders that had been introduced at the point
         // this variable was created -- though it may change over time
         // as the variable is unified.
-        let universe_index = match self.table.unify.probe_value(var) {
+        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"),
         };
 
         OccursCheck::new(self, var, universe_index).check_ty(ty)?;
 
-        let value_index = ValueIndex::new(self.table.values.len());
-        self.table.values.push(Arc::new(ty.clone()));
-        self.table.unify.unify_var_value(var, TyInferenceValue::Bound(value_index)).unwrap();
+        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();
         debug!("unify_var_ty: var {:?} set to {:?}", var, ty);
 
         Ok(())
@@ -340,14 +340,14 @@ impl<'u, 't> OccursCheck<'u, 't> {
 
             Ty::Var(depth) => {
                 let v = TyInferenceVariable::from_depth(depth - self.binders);
-                let ui = match self.unifier.table.unify.probe_value(v) {
+                let ui = match self.unifier.table.ty_unify.probe_value(v) {
                     TyInferenceValue::Unbound(ui) => ui,
                     TyInferenceValue::Bound(_) => {
                         unreachable!("expected `parameter` to be normalized")
                     }
                 };
 
-                if self.unifier.table.unify.unioned(v, self.var) {
+                if self.unifier.table.ty_unify.unioned(v, self.var) {
                     bail!("cycle during unification");
                 }
 
@@ -360,7 +360,7 @@ impl<'u, 't> OccursCheck<'u, 't> {
                     // This is OK, if ?B is promoted to universe 0.
                     self.unifier
                         .table
-                        .unify
+                        .ty_unify
                         .unify_var_value(v, TyInferenceValue::Unbound(self.universe_index))
                         .unwrap();
                 }

Original file line number	Diff line number	Diff line change
`@@ -18,8 +18,8 @@ use self::lifetime_var::LifetimeInferenceVariable;`
`18`	`18`
`19`	`19`	`#[derive(Clone)]`
`20`	`20`	`pub struct InferenceTable {`
`21`		`- unify: ena::UnificationTable<TyInferenceVariable>,`
`22`		`- values: Vec<Arc<Ty>>,`
	`21`	`+ ty_unify: ena::UnificationTable<TyInferenceVariable>,`
	`22`	`+ ty_values: Vec<Arc<Ty>>,`
`23`	`23`
`24`	`24`	`krate_unify: ena::UnificationTable<KrateInferenceVariable>,`
`25`	`25`
`@@ -30,8 +30,10 @@ pub struct InferenceTable {`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`pub struct InferenceSnapshot {`
`33`		`- unify_snapshot: ena::Snapshot<TyInferenceVariable>,`
`34`		`- values_len: usize,`
	`33`	`+ ty_unify_snapshot: ena::Snapshot<TyInferenceVariable>,`
	`34`	`+ ty_values_len: usize,`
	`35`	`+`
	`36`	`+ krate_unify_snapshot: ena::Snapshot<KrateInferenceVariable>,`
`35`	`37`	`}`
`36`	`38`
`37`	`39`	`pub type ParameterInferenceVariable = ParameterKind<TyInferenceVariable,`
`@@ -41,9 +43,9 @@ pub type ParameterInferenceVariable = ParameterKind<TyInferenceVariable,`
`41`	`43`	`impl InferenceTable {`
`42`	`44`	`pub fn new() -> Self {`
`43`	`45`	`InferenceTable {`
`44`		`- unify: ena::UnificationTable::new(),`
	`46`	`+ ty_unify: ena::UnificationTable::new(),`
`45`	`47`	`krate_unify: ena::UnificationTable::new(),`
`46`		`- values: vec![],`
	`48`	`+ ty_values: vec![],`
`47`	`49`	`lifetime_vars: vec![],`
`48`	`50`	`}`
`49`	`51`	`}`
`@@ -57,7 +59,7 @@ impl InferenceTable {`
`57`	`59`	`}`
`58`	`60`
`59`	`61`	`pub fn new_variable(&mut self, ui: UniverseIndex) -> TyInferenceVariable {`
`60`		`- self.unify.new_key(TyInferenceValue::Unbound(ui))`
	`62`	`+ self.ty_unify.new_key(TyInferenceValue::Unbound(ui))`
`61`	`63`	`}`
`62`	`64`
`63`	`65`	`pub fn new_lifetime_variable(&mut self, ui: UniverseIndex) -> LifetimeInferenceVariable {`
`@@ -84,20 +86,22 @@ impl InferenceTable {`
`84`	`86`	`}`
`85`	`87`
`86`	`88`	`pub fn snapshot(&mut self) -> InferenceSnapshot {`
`87`		`- let unify_snapshot = self.unify.snapshot();`
	`89`	`+ let ty_unify_snapshot = self.ty_unify.snapshot();`
	`90`	`+ let krate_unify_snapshot = self.krate_unify.snapshot();`
`88`	`91`	`InferenceSnapshot {`
`89`		`- unify_snapshot: unify_snapshot,`
`90`		`- values_len: self.values.len(),`
	`92`	`+ ty_unify_snapshot,`
	`93`	`+ krate_unify_snapshot,`
	`94`	`+ ty_values_len: self.ty_values.len(),`
`91`	`95`	`}`
`92`	`96`	`}`
`93`	`97`
`94`	`98`	`pub fn rollback_to(&mut self, snapshot: InferenceSnapshot) {`
`95`		`- self.unify.rollback_to(snapshot.unify_snapshot);`
`96`		`- self.values.truncate(snapshot.values_len);`
	`99`	`+ self.ty_unify.rollback_to(snapshot.ty_unify_snapshot);`
	`100`	`+ self.ty_values.truncate(snapshot.ty_values_len);`
`97`	`101`	`}`
`98`	`102`
`99`	`103`	`fn commit(&mut self, snapshot: InferenceSnapshot) {`
`100`		`- self.unify.commit(snapshot.unify_snapshot);`
	`104`	`+ self.ty_unify.commit(snapshot.ty_unify_snapshot);`
`101`	`105`	`}`
`102`	`106`
`103`	`107`	`fn commit_if_ok<F, R>(&mut self, op: F) -> Result<R>`
`@@ -120,9 +124,9 @@ impl InferenceTable {`
`120`	`124`	`fn normalize_shallow(&mut self, leaf: &Ty) -> Option<Arc<Ty>> {`
`121`	`125`	`leaf.inference_var()`
`122`	`126`	`.and_then(\|var\| {`
`123`		`- match self.unify.probe_value(var) {`
	`127`	`+ match self.ty_unify.probe_value(var) {`
`124`	`128`	`TyInferenceValue::Unbound(_) => None,`
`125`		`- TyInferenceValue::Bound(val) => Some(self.values[val.as_usize()].clone()),`
	`129`	`+ TyInferenceValue::Bound(val) => Some(self.ty_values[val.as_usize()].clone()),`
`126`	`130`	`}`
`127`	`131`	`})`
`128`	`132`	`}`
`@@ -135,9 +139,9 @@ impl InferenceTable {`
`135`	`139`	`}`
`136`	`140`
`137`	`141`	`fn probe_var(&mut self, var: TyInferenceVariable) -> Option<Arc<Ty>> {`
`138`		`- match self.unify.probe_value(var) {`
	`142`	`+ match self.ty_unify.probe_value(var) {`
`139`	`143`	`TyInferenceValue::Unbound(_) => None,`
`140`		`- TyInferenceValue::Bound(val) => Some(self.values[val.as_usize()].clone()),`
	`144`	`+ TyInferenceValue::Bound(val) => Some(self.ty_values[val.as_usize()].clone()),`
`141`	`145`	`}`
`142`	`146`	`}`
`143`	`147`