Add handling for one-sided InferVar

Author: varkor

src/librustc/infer/combine.rs

@@ -167,7 +167,7 @@ impl<'infcx, 'gcx, 'tcx> InferCtxt<'infcx, 'gcx, 'tcx> {
         }
     }
 
-    fn unify_const_variable(&self,
+    pub fn unify_const_variable(&self,
                             vid_is_expected: bool,
                             vid: ty::ConstVid<'tcx>,
                             val: &'tcx Const<'tcx>)

src/librustc/infer/equate.rs

@@ -112,29 +112,30 @@ impl<'combine, 'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx>
 
     fn consts(&mut self, a: &'tcx ty::Const<'tcx>, b: &'tcx ty::Const<'tcx>)
         -> RelateResult<'tcx, &'tcx ty::Const<'tcx>> {
-        // TODO(const_generics): missing handling for when only one side is an InferVar
         debug!("{}.consts({:?}, {:?})", self.tag(), a, b);
         if a == b { return Ok(a); }
 
         let infcx = self.fields.infcx;
         let a = replace_const_if_possible(infcx.const_unification_table.borrow_mut(), a);
         let b = replace_const_if_possible(infcx.const_unification_table.borrow_mut(), b);
+        let a_is_expected = self.a_is_expected();
         match (a.val, b.val) {
             (ConstValue::Infer(InferConst::Var(a_vid)),
              ConstValue::Infer(InferConst::Var(b_vid))) => {
-                let a_is_expected = self.a_is_expected();
                 infcx.const_unification_table
                     .borrow_mut()
                     .unify_var_var(a_vid, b_vid)
                     .map_err(|e| const_unification_error(a_is_expected, e))?;
                 Ok(a)
             }
 
-            (ConstValue::Infer(InferConst::Var(_)), _) => {
+            (ConstValue::Infer(InferConst::Var(a_id)), _) => {
+                self.fields.infcx.unify_const_variable(a_is_expected, a_id, b)?;
                 Ok(a)
             }
 
-            (_, ConstValue::Infer(InferConst::Var(_))) => {
+            (_, ConstValue::Infer(InferConst::Var(b_id))) => {
+                self.fields.infcx.unify_const_variable(!a_is_expected, b_id, a)?;
                 Ok(a)
             }
 
@@ -153,5 +154,3 @@ impl<'combine, 'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx>
         self.fields.higher_ranked_sub(b, a, self.a_is_expected)
     }
 }
-
-

src/librustc/infer/sub.rs

@@ -146,7 +146,6 @@ impl<'combine, 'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx>
 
     fn consts(&mut self, a: &'tcx ty::Const<'tcx>, b: &'tcx ty::Const<'tcx>)
         -> RelateResult<'tcx, &'tcx ty::Const<'tcx>> {
-        // TODO(const_generics): missing handling for when only one side is an InferVar
         debug!("{}.consts({:?}, {:?})", self.tag(), a, b);
         if a == b { return Ok(a); }
 
@@ -156,19 +155,24 @@ impl<'combine, 'infcx, 'gcx, 'tcx> TypeRelation<'infcx, 'gcx, 'tcx>
 
         // Consts can only be equal or unequal to each other: there's no subtyping
         // relation, so we're just going to perform equating here instead.
+        let a_is_expected = self.a_is_expected();
         match (a.val, b.val) {
             (ConstValue::Infer(InferConst::Var(a_vid)),
              ConstValue::Infer(InferConst::Var(b_vid))) => {
-                let a_is_expected = self.a_is_expected();
                 infcx.const_unification_table
                     .borrow_mut()
                     .unify_var_var(a_vid, b_vid)
                     .map_err(|e| const_unification_error(a_is_expected, e))?;
                 Ok(a)
             }
 
-            (ConstValue::Infer(InferConst::Var(_)), _) |
-            (_, ConstValue::Infer(InferConst::Var(_))) => {
+            (ConstValue::Infer(InferConst::Var(a_id)), _) => {
+                self.fields.infcx.unify_const_variable(a_is_expected, a_id, b)?;
+                Ok(a)
+            }
+
+            (_, ConstValue::Infer(InferConst::Var(b_id))) => {
+                self.fields.infcx.unify_const_variable(!a_is_expected, b_id, a)?;
                 Ok(a)
             }