Const parameters should impose no variance constraints

src/librustc_typeck/variance/constraints.rs

@@ -4,7 +4,6 @@
 //! We walk the set of items and, for each member, generate new constraints.
 
 use hir::def_id::DefId;
-use rustc::mir::interpret::ConstValue;
 use rustc::ty::subst::{SubstsRef, UnpackedKind};
 use rustc::ty::{self, Ty, TyCtxt};
 use rustc::hir;
@@ -239,8 +238,8 @@ fn add_constraints_from_invariant_substs(&mut self,
                 UnpackedKind::Type(ty) => {
                     self.add_constraints_from_ty(current, ty, variance_i)
                 }
-                UnpackedKind::Const(ct) => {
-                    self.add_constraints_from_const(current, ct, variance_i)
+                UnpackedKind::Const(_) => {
+                    // Consts impose no constraints.
                 }
             }
         }
@@ -275,9 +274,8 @@ fn add_constraints_from_ty(&mut self,
                 self.add_constraints_from_mt(current, &ty::TypeAndMut { ty, mutbl }, variance);
             }
 
-            ty::Array(typ, len) => {
+            ty::Array(typ, _) => {
                 self.add_constraints_from_ty(current, typ, variance);
-                self.add_constraints_from_const(current, len, variance);
             }
 
             ty::Slice(typ) => {
@@ -395,8 +393,8 @@ fn add_constraints_from_substs(&mut self,
                 UnpackedKind::Type(ty) => {
                     self.add_constraints_from_ty(current, ty, variance_i)
                 }
-                UnpackedKind::Const(ct) => {
-                    self.add_constraints_from_const(current, ct, variance_i)
+                UnpackedKind::Const(_) => {
+                    // Consts impose no constraints.
                 }
             }
         }
@@ -449,24 +447,6 @@ fn add_constraints_from_region(&mut self,
         }
     }
 
-    fn add_constraints_from_const(
-        &mut self,
-        current: &CurrentItem,
-        ct: &ty::Const<'tcx>,
-        variance: VarianceTermPtr<'a>
-    ) {
-        debug!(
-            "add_constraints_from_const(ct={:?}, variance={:?})",
-            ct,
-            variance
-        );
-
-        self.add_constraints_from_ty(current, ct.ty, variance);
-        if let ConstValue::Param(ref data) = ct.val {
-            self.add_constraint(current, data.index, variance);
-        }
-    }
-
     /// Adds constraints appropriate for a mutability-type pair
     /// appearing in a context with ambient variance `variance`
     fn add_constraints_from_mt(&mut self,

src/librustc_typeck/variance/solve.rs

@@ -85,12 +85,19 @@ fn create_map(&self) -> FxHashMap<DefId, Lrc<Vec<ty::Variance>>> {
         self.terms_cx.inferred_starts.iter().map(|(&id, &InferredIndex(start))| {
             let def_id = tcx.hir().local_def_id_from_hir_id(id);
             let generics = tcx.generics_of(def_id);
+            let count = generics.count();
 
-            let mut variances = solutions[start..start+generics.count()].to_vec();
-
+            let mut variances = solutions[start..(start + count)].to_vec();
             debug!("id={} variances={:?}", id, variances);
 
-            // Functions can have unused type parameters: make those invariant.
+            // Const parameters are always invariant.
+            for (idx, param) in generics.params.iter().enumerate() {
+                if let ty::GenericParamDefKind::Const = param.kind {
+                    variances[idx] = ty::Invariant;
+                }
+            }
+
+            // Functions are permitted to have unused generic parameters: make those invariant.
             if let ty::FnDef(..) = tcx.type_of(def_id).sty {
                 for variance in &mut variances {
                     if *variance == ty::Bivariant {

src/librustc_typeck/variance/terms.rs

@@ -119,7 +119,7 @@ fn add_inferreds_for_item(&mut self, id: hir::HirId) {
         // for a particular item are assigned continuous indices.
 
         let arena = self.arena;
-        self.inferred_terms.extend((start..start+count).map(|i| {
+        self.inferred_terms.extend((start..(start + count)).map(|i| {
             &*arena.alloc(InferredTerm(InferredIndex(i)))
         }));
     }