Replace ConstVariableTable with UnificationTable

Author: varkor

src/librustc/infer/combine.rs

@@ -28,7 +28,7 @@ use super::{InferCtxt, MiscVariable, TypeTrace};
 use super::lub::Lub;
 use super::sub::Sub;
 use super::type_variable::TypeVariableValue;
-use super::const_variable::ConstVariableValue;
+use super::unify_key::{ConstVarValue, ConstVariableValue, ConstVariableOrigin};
 
 use crate::hir::def_id::DefId;
 use crate::mir::interpret::ConstValue;
@@ -40,7 +40,7 @@ use crate::ty::subst::SubstsRef;
 use crate::traits::{Obligation, PredicateObligations};
 
 use syntax::ast;
-use syntax_pos::Span;
+use syntax_pos::{Span, DUMMY_SP};
 
 #[derive(Clone)]
 pub struct CombineFields<'infcx, 'gcx: 'infcx+'tcx, 'tcx: 'infcx> {
@@ -166,7 +166,10 @@ impl<'infcx, 'gcx, 'tcx> InferCtxt<'infcx, 'gcx, 'tcx> {
     ) -> RelateResult<'tcx, &'tcx LazyConst<'tcx>> {
         self.const_unification_table
             .borrow_mut()
-            .unify_var_value(vid, ConstVariableValue::Known { value })
+            .unify_var_value(vid, ConstVarValue {
+                origin: ConstVariableOrigin::ConstInference(DUMMY_SP),
+                val: ConstVariableValue::Known { value },
+            })
             .map_err(|e| const_unification_error(vid_is_expected, e))?;
         Ok(value)
     }
@@ -590,7 +593,7 @@ impl<'cx, 'gcx, 'tcx> TypeRelation<'cx, 'gcx, 'tcx> for Generalizer<'cx, 'gcx, '
                 ..
             }) => {
                 let mut variable_table = self.infcx.const_unification_table.borrow_mut();
-                match variable_table.probe(*vid).known() {
+                match variable_table.probe_value(*vid).val.known() {
                     Some(u) => {
                         self.relate(&u, &u)
                     }

src/librustc/infer/const_variable.rs

@@ -8,6 +8,7 @@ use crate::ty::TyVar;
 use crate::ty::subst::SubstsRef;
 use crate::ty::relate::{self, Relate, RelateResult, TypeRelation};
 use crate::mir::interpret::ConstValue;
+use crate::infer::unify_key::replace_if_possible;
 
 /// Ensures `a` is made equal to `b`. Returns `a` on success.
 pub struct Equate<'combine, 'infcx: 'combine, 'gcx: 'infcx+'tcx, 'tcx: 'infcx> {
@@ -110,8 +111,8 @@ impl<'combine, 'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx>
         if a == b { return Ok(a); }
 
         let infcx = self.fields.infcx;
-        let a = infcx.const_unification_table.borrow_mut().replace_if_possible(a);
-        let b = infcx.const_unification_table.borrow_mut().replace_if_possible(b);
+        let a = replace_if_possible(infcx.const_unification_table.borrow_mut(), a);
+        let b = replace_if_possible(infcx.const_unification_table.borrow_mut(), b);
         let a_is_expected = self.a_is_expected();
         if let (&ty::LazyConst::Evaluated(a_eval), &ty::LazyConst::Evaluated(b_eval)) = (a, b) {
             match (a_eval.val, b_eval.val) {

src/librustc/infer/equate.rs

@@ -232,7 +232,8 @@ impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for TypeFreshener<'a, 'gcx, 'tcx> {
                 ConstValue::Infer(ty::InferConst::Var(v)) => {
                     let opt_ct = self.infcx.const_unification_table
                         .borrow_mut()
-                        .probe(*v)
+                        .probe_value(*v)
+                        .val
                         .known();
                     return self.freshen_const(
                         opt_ct,

src/librustc/infer/freshen.rs

@@ -181,26 +181,16 @@ impl<'a, 'gcx, 'tcx> TypeFolder<'gcx, 'tcx> for InferenceFudger<'a, 'gcx, 'tcx>
             val: ConstValue::Infer(ty::InferConst::Var(vid)),
             ty,
         }) = *ct {
-            match self.const_variables.get(&vid) {
-                None => {
-                    // This variable was created before the
-                    // "fudging".  Since we refresh all
-                    // variables to their binding anyhow, we know
-                    // that it is unbound, so we can just return
-                    // it.
-                    debug_assert!(
-                        self.infcx.const_unification_table.borrow_mut()
-                        .probe(vid)
-                        .is_unknown()
-                    );
-                    ct
-                }
-                Some(&origin) => {
-                    // This variable was created during the
-                    // fudging. Recreate it with a fresh variable
-                    // here.
-                    self.infcx.next_const_var(ty, origin)
-                }
+            if self.const_variables.contains(&vid) {
+                // This variable was created during the
+                // fudging. Recreate it with a fresh variable
+                // here.
+                let origin = self.infcx.const_unification_table.borrow_mut()
+                    .probe_value(vid)
+                    .origin;
+                self.infcx.next_const_var(ty, origin)
+            } else {
+                ct
             }
         } else {
             ct.super_fold_with(self)