Fix rebase fallout

varkor · varkor · commit 7cc81d01176d · 2018-08-23T18:50:30.000+01:00
diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs
@@ -2327,11 +2327,9 @@ impl<'a> LoweringContext<'a> {
                 }
             }
             GenericParamKind::Const { ref ty } => {
-                let mut name = self.lower_ident(param.ident);
-
                 hir::GenericParam {
                     id: self.lower_node_id(param.id).node_id,
-                    name: hir::ParamName::Plain(name),
+                    name: hir::ParamName::Plain(param.ident),
                     span: param.ident.span,
                     pure_wrt_drop: attr::contains_name(&param.attrs, "may_dangle"),
                     attrs: self.lower_attrs(&param.attrs),
diff --git a/src/librustc/infer/canonical.rs b/src/librustc/infer/canonical.rs
diff --git a/src/librustc/infer/canonical/mod.rs b/src/librustc/infer/canonical/mod.rs
@@ -110,6 +110,9 @@ pub enum CanonicalTyVarKind {
     /// General type variable `?T` that can be unified with arbitrary types.
     General,
 
+    /// Const type variable `?C` that can be unified with const expressions.
+    Const,
+
     /// Integral type variable `?I` (that can only be unified with integral types).
     Int,
 
@@ -244,9 +247,8 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {
                     CanonicalTyVarKind::General => {
                         self.next_ty_var(TypeVariableOrigin::MiscVariable(span))
                     }
-
+                    CanonicalTyVarKind::Const => self.tcx.mk_const_var(self.next_const_var_id()),
                     CanonicalTyVarKind::Int => self.tcx.mk_int_var(self.next_int_var_id()),
-
                     CanonicalTyVarKind::Float => self.tcx.mk_float_var(self.next_float_var_id()),
                 };
                 ty.into()
diff --git a/src/librustc/infer/canonical/query_result.rs b/src/librustc/infer/canonical/query_result.rs
@@ -433,6 +433,9 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {
                         opt_values[index] = Some(*original_value);
                     }
                 }
+                UnpackedKind::Const(_) => {
+                    unimplemented!() // TODO(const_generics)
+                }
             }
         }
 
@@ -516,6 +519,9 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {
                                 t1, r2,
                             ))),
                         ),
+
+                        // TODO(const_generics): does it even make sense to specify that a const outlives something?
+                        UnpackedKind::Const(_) => unimplemented!(),
                     }
                 }),
         ) as Box<dyn Iterator<Item = _>>
diff --git a/src/librustc/mir/interpret/value.rs b/src/librustc/mir/interpret/value.rs
@@ -14,6 +14,8 @@ pub enum ConstValue<'tcx> {
     /// to allow HIR creation to happen for everything before needing to be able to run constant
     /// evaluation
     Unevaluated(DefId, &'tcx Substs<'tcx>),
+    /// A const generic parameter.
+    Param(ty::ParamConst),
     /// Used only for types with layout::abi::Scalar ABI and ZSTs
     ///
     /// Not using the enum `Value` to encode that this must not be `Undef`
@@ -33,6 +35,7 @@ impl<'tcx> ConstValue<'tcx> {
             ConstValue::Unevaluated(..) |
             ConstValue::ByRef(..) |
             ConstValue::ScalarPair(..) => None,
+            ConstValue::Param(_) => unimplemented!(), // TODO(const_generics)
             ConstValue::Scalar(val) => Some(val),
         }
     }
diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs
@@ -27,13 +27,12 @@ use ich::{StableHashingContext, NodeIdHashingMode};
 use infer::canonical::{CanonicalVarInfo, CanonicalVarInfos};
 use infer::outlives::free_region_map::FreeRegionMap;
 use middle::cstore::CrateStoreDyn;
-use middle::const_val::ConstVal;
 use middle::cstore::EncodedMetadata;
 use middle::lang_items;
 use middle::resolve_lifetime::{self, ObjectLifetimeDefault};
 use middle::stability;
 use mir::{self, Mir, interpret};
-use mir::interpret::Allocation;
+use mir::interpret::{Allocation, ConstValue};
 use ty::subst::{Kind, Substs, Subst};
 use ty::ReprOptions;
 use traits;
@@ -2555,7 +2554,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
     pub fn mk_const_param(self, index: u32, name: InternedString, ty: Ty<'tcx>) -> &'tcx ty::Const<'tcx> {
         debug!("mk_const_param: index={} name={:?} ty={:?}", index, name, ty);
         self.mk_const(ty::Const {
-            val: ConstVal::Param(ParamConst { index, name }),
+            val: ConstValue::Param(ParamConst { index, name }),
             ty,
         })
     }
diff --git a/src/librustc/ty/structural_impls.rs b/src/librustc/ty/structural_impls.rs
@@ -1143,15 +1143,15 @@ impl<'tcx> TypeFoldable<'tcx> for ConstValue<'tcx> {
             ConstValue::Unevaluated(def_id, substs) => {
                 ConstValue::Unevaluated(def_id, substs.fold_with(folder))
             }
-            ConstVal::Param(param) => ConstVal::Param(param),
+            ConstValue::Param(param) => ConstValue::Param(param),
         }
     }
 
     fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {
         match *self {
             ConstValue::Scalar(_) |
             ConstValue::ScalarPair(_, _) |
-            ConstVal::Param(_) | // TODO(const_generics)
+            ConstValue::Param(_) | // TODO(const_generics)
             ConstValue::ByRef(_, _) => false,
             ConstValue::Unevaluated(_, substs) => substs.visit_with(visitor),
         }
diff --git a/src/librustc/ty/util.rs b/src/librustc/ty/util.rs
@@ -21,8 +21,8 @@ use ty::subst::{Substs, UnpackedKind};
 use ty::query::TyCtxtAt;
 use ty::TyKind::*;
 use ty::layout::{Integer, IntegerExt};
+use mir::interpret::ConstValue;
 use util::common::ErrorReported;
-use middle::const_val::ConstVal;
 use middle::lang_items;
 
 use rustc_data_structures::stable_hasher::{StableHasher, HashStable};
@@ -508,9 +508,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
                     }) => {
                         !impl_generics.type_param(pt, self).pure_wrt_drop
                     }
-                    UnpackedKind::Const(&ty::Const {
-                        val: ConstVal::Param(ref pc), ..
-                    }) => {
+                    UnpackedKind::Const(&ty::Const { val: ConstValue::Param(ref pc), .. }) => {
                         !impl_generics.const_param(pc, self).pure_wrt_drop
                     }
                     UnpackedKind::Lifetime(_) |
diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
@@ -1284,12 +1284,12 @@ define_print! {
 }
 
 define_print! {
-    ('tcx) ConstVal<'tcx>, (self, f, cx) {
+    ('tcx) ConstValue<'tcx>, (self, f, cx) {
         display {
             match self {
-                ConstVal::Value(value) => write!(f, "{:?}", value), // TODO(const_generics)
-                ConstVal::Unevaluated(..) => write!(f, "_"),
-                ConstVal::Param(ParamConst { name, .. }) => write!(f, "{}", name),
+                ConstValue::Unevaluated(..) => write!(f, "_"),
+                ConstValue::Param(ParamConst { name, .. }) => write!(f, "{}", name),
+                _ => write!(f, "{:?}", self), // TODO(const_generics)
             }
         }
     }
diff --git a/src/librustc_codegen_llvm/mir/operand.rs b/src/librustc_codegen_llvm/mir/operand.rs
@@ -90,6 +90,7 @@ impl OperandRef<'ll, 'tcx> {
 
         let val = match val.val {
             ConstValue::Unevaluated(..) => bug!(),
+            ConstValue::Param(_) => unimplemented!(), // TODO(const_generics)
             ConstValue::Scalar(x) => {
                 let scalar = match layout.abi {
                     layout::Abi::Scalar(ref x) => x,
diff --git a/src/librustc_lint/bad_style.rs b/src/librustc_lint/bad_style.rs
@@ -423,7 +423,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for NonUpperCaseGlobals {
                 NonUpperCaseGlobals::check_upper_case(
                     cx,
                     "const parameter",
-                    param.name.name(),
+                    param.name.ident().name,
                     param.span
                 );
             }
diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs
@@ -1351,6 +1351,7 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> {
             variances: LazySeq::empty(),
             generics: None,
             predicates: None,
+            predicates_defined_on: None,
 
             mir: None,
         }
diff --git a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/region_name.rs
@@ -513,7 +513,13 @@ impl<'tcx> RegionInferenceContext<'tcx> {
                     search_stack.push((ty, hir_ty));
                 }
 
-                (UnpackedKind::Lifetime(_), _) | (UnpackedKind::Type(_), _) => {
+                (UnpackedKind::Const(_ct), hir::GenericArg::Const(_hir_ct)) => {
+                    unimplemented!() // TODO(const_generics)
+                }
+
+                (UnpackedKind::Lifetime(_), _)
+                | (UnpackedKind::Type(_), _)
+                | (UnpackedKind::Const(_), _) => {
                     // I *think* that HIR lowering should ensure this
                     // doesn't happen, even in erroneous
                     // programs. Else we should use delay-span-bug.
diff --git a/src/librustc_mir/borrow_check/nll/type_check/constraint_conversion.rs b/src/librustc_mir/borrow_check/nll/type_check/constraint_conversion.rs
@@ -129,6 +129,10 @@ impl<'a, 'gcx, 'tcx> ConstraintConversion<'a, 'gcx, 'tcx> {
                     param_env,
                 ).type_must_outlive(origin, t1, r2);
             }
+
+            UnpackedKind::Const(_c1) => {
+                unimplemented!() // TODO(const_generics)
+            }
         }
     }
 
diff --git a/src/librustc_mir/hair/pattern/_match.rs b/src/librustc_mir/hair/pattern/_match.rs
@@ -1338,6 +1338,7 @@ fn slice_pat_covered_by_constructor<'tcx>(
                 ConstValue::Unevaluated(..) |
                 ConstValue::ByRef(..) => bug!("unexpected ConstValue: {:?}", const_val),
                 ConstValue::Scalar(val) | ConstValue::ScalarPair(val, _) => val,
+                ConstValue::Param(_) => unimplemented!(), // TODO(const_generics)
             };
             if let Ok(ptr) = val.to_ptr() {
                 let is_array_ptr = const_val.ty
diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs
@@ -645,6 +645,7 @@ fn compare_number_of_generics<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     let num_trait_m_const_params = trait_m_generics.own_counts().consts;
 
     if num_impl_m_const_params != num_trait_m_const_params {
+        /*
         let impl_m_node_id = tcx.hir.as_local_node_id(impl_m.def_id).unwrap();
         let impl_m_item = tcx.hir.expect_impl_item(impl_m_node_id);
         let span = if impl_m_item.generics.params.is_empty() {
@@ -655,7 +656,7 @@ fn compare_number_of_generics<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 
         let mut err = struct_span_err!(tcx.sess,
                                        span,
-                                       E0049, // TDOO(const_generics): new error code?
+                                       E0049, // TODO(const_generics): new error code?
                                        "method `{}` has {} const parameter{} but its trait \
                                         declaration has {} const parameter{}",
                                        trait_m.name,
@@ -692,7 +693,7 @@ fn compare_number_of_generics<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                 suffix.as_ref().map(|s| &s[..]).unwrap_or("")));
 
         err.emit();
-
+        */
         return Err(ErrorReported);
     }
 
diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs
@@ -17,7 +17,7 @@ use rustc::ty::{self, Lift, Ty, TyCtxt, GenericParamDefKind, TypeFoldable};
 use rustc::ty::subst::{Subst, Substs};
 use rustc::ty::util::ExplicitSelf;
 use rustc::util::nodemap::{FxHashSet, FxHashMap};
-use rustc::middle::const_val::ConstVal;
+use rustc::mir::interpret::ConstValue;
 use rustc::middle::lang_items;
 use rustc::infer::anon_types::may_define_existential_type;
 
@@ -472,13 +472,10 @@ fn check_where_clauses<'a, 'gcx, 'fcx, 'tcx>(
             }
 
             fn visit_const(&mut self, c: &'tcx ty::Const<'tcx>) -> bool {
-                match c.val {
-                    ConstVal::Param(p) => {
-                        self.params.insert(p.index);
-                        c.super_visit_with(self)
-                    }
-                    _ => c.super_visit_with(self)
+                if let ConstValue::Param(param) = c.val {
+                    self.params.insert(param.index);
                 }
+                c.super_visit_with(self)
             }
         }
         let mut param_count = CountParams { params: FxHashSet() };
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
@@ -956,7 +956,7 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 
         // TODO(const_generics): should this be split out to put const parameters after type parameters?
         GenericParamKind::Const { ref ty } => {
-            if param.name.name() == keywords::SelfType.name() {
+            if param.name.ident().name == keywords::SelfType.name() {
                 span_bug!(param.span,  "`Self` should not be the name of a regular parameter");
             }
 
@@ -965,7 +965,7 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
 
             let const_param = ty::GenericParamDef {
                 index: type_start + i as u32,
-                name: param.name.name().as_interned_str(),
+                name: param.name.ident().as_interned_str(),
                 def_id: const_param_def_id,
                 pure_wrt_drop: param.pure_wrt_drop,
                 kind: ty::GenericParamDefKind::Const{
diff --git a/src/librustc_typeck/constrained_type_params.rs b/src/librustc_typeck/constrained_type_params.rs
@@ -8,9 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use rustc::middle::const_val::ConstVal;
 use rustc::ty::{self, Ty, TyCtxt};
 use rustc::ty::fold::{TypeFoldable, TypeVisitor};
+use rustc::mir::interpret::ConstValue;
 use rustc::util::nodemap::FxHashSet;
 
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
@@ -92,7 +92,7 @@ impl<'tcx> TypeVisitor<'tcx> for ParameterCollector {
 
     fn visit_const(&mut self, c: &'tcx ty::Const<'tcx>) -> bool {
         match c.val {
-            ConstVal::Param(data) => {
+            ConstValue::Param(data) => {
                 debug!("ParameterCollector::visit_const: visit const param: {}", data);
                 self.parameters.push(Parameter::from(data));
             }
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -1488,7 +1488,7 @@ impl Clean<GenericParamDef> for hir::GenericParam {
                 })
             }
             hir::GenericParamKind::Const { ref ty } => {
-                (self.name.name().clean(cx), GenericParamDefKind::Const {
+                (self.name.ident().name.clean(cx), GenericParamDefKind::Const {
                     did: cx.tcx.hir.local_def_id(self.id),
                     ty: ty.clean(cx),
                 })
@@ -3754,6 +3754,9 @@ fn print_const(cx: &DocContext, n: &ty::Const) -> String {
                 inline::print_inlined_const(cx, def_id)
             }
         },
+        ConstValue::Param(..) => {
+            unimplemented!() // TODO(const_generics)
+        }
         _ => {
             let mut s = String::new();
             ::rustc::mir::fmt_const_val(&mut s, n).expect("fmt_const_val failed");
@@ -3764,9 +3767,6 @@ fn print_const(cx: &DocContext, n: &ty::Const) -> String {
             }
             s
         },
-        ConstVal::Param(..) => {
-            unimplemented!() // TODO(const_generics)
-        }
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -2327,11 +2327,9 @@ impl<'a> LoweringContext<'a> {`
`2327`	`2327`	`}`
`2328`	`2328`	`}`
`2329`	`2329`	`GenericParamKind::Const { ref ty } => {`
`2330`		`- let mut name = self.lower_ident(param.ident);`
`2331`		`-`
`2332`	`2330`	`hir::GenericParam {`
`2333`	`2331`	`id: self.lower_node_id(param.id).node_id,`
`2334`		`- name: hir::ParamName::Plain(name),`
	`2332`	`+ name: hir::ParamName::Plain(param.ident),`
`2335`	`2333`	`span: param.ident.span,`
`2336`	`2334`	`pure_wrt_drop: attr::contains_name(&param.attrs, "may_dangle"),`
`2337`	`2335`	`attrs: self.lower_attrs(&param.attrs),`
Original file line number	Diff line number	Diff line change
`@@ -433,6 +433,9 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {`
`433`	`433`	`opt_values[index] = Some(*original_value);`
`434`	`434`	`}`
`435`	`435`	`}`
	`436`	`+ UnpackedKind::Const(_) => {`
	`437`	`+ unimplemented!() // TODO(const_generics)`
	`438`	`+ }`
`436`	`439`	`}`
`437`	`440`	`}`
`438`	`441`
`@@ -516,6 +519,9 @@ impl<'cx, 'gcx, 'tcx> InferCtxt<'cx, 'gcx, 'tcx> {`
`516`	`519`	`t1, r2,`
`517`	`520`	`))),`
`518`	`521`	`),`
	`522`	`+`
	`523`	`+ // TODO(const_generics): does it even make sense to specify that a const outlives something?`
	`524`	`+ UnpackedKind::Const(_) => unimplemented!(),`
`519`	`525`	`}`
`520`	`526`	`}),`
`521`	`527`	`) as Box<dyn Iterator<Item = _>>`
Original file line number	Diff line number	Diff line change
`@@ -1143,15 +1143,15 @@ impl<'tcx> TypeFoldable<'tcx> for ConstValue<'tcx> {`
`1143`	`1143`	`ConstValue::Unevaluated(def_id, substs) => {`
`1144`	`1144`	`ConstValue::Unevaluated(def_id, substs.fold_with(folder))`
`1145`	`1145`	`}`
`1146`		`- ConstVal::Param(param) => ConstVal::Param(param),`
	`1146`	`+ ConstValue::Param(param) => ConstValue::Param(param),`
`1147`	`1147`	`}`
`1148`	`1148`	`}`
`1149`	`1149`
`1150`	`1150`	`fn super_visit_with<V: TypeVisitor<'tcx>>(&self, visitor: &mut V) -> bool {`
`1151`	`1151`	`match *self {`
`1152`	`1152`	`ConstValue::Scalar(_) \|`
`1153`	`1153`	`ConstValue::ScalarPair(_, _) \|`
`1154`		`- ConstVal::Param(_) \| // TODO(const_generics)`
	`1154`	`+ ConstValue::Param(_) \| // TODO(const_generics)`
`1155`	`1155`	`ConstValue::ByRef(_, _) => false,`
`1156`	`1156`	`ConstValue::Unevaluated(_, substs) => substs.visit_with(visitor),`
`1157`	`1157`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1284,12 +1284,12 @@ define_print! {`
`1284`	`1284`	`}`
`1285`	`1285`
`1286`	`1286`	`define_print! {`
`1287`		`- ('tcx) ConstVal<'tcx>, (self, f, cx) {`
	`1287`	`+ ('tcx) ConstValue<'tcx>, (self, f, cx) {`
`1288`	`1288`	`display {`
`1289`	`1289`	`match self {`
`1290`		`- ConstVal::Value(value) => write!(f, "{:?}", value), // TODO(const_generics)`
`1291`		`- ConstVal::Unevaluated(..) => write!(f, "_"),`
`1292`		`- ConstVal::Param(ParamConst { name, .. }) => write!(f, "{}", name),`
	`1290`	`+ ConstValue::Unevaluated(..) => write!(f, "_"),`
	`1291`	`+ ConstValue::Param(ParamConst { name, .. }) => write!(f, "{}", name),`
	`1292`	`+ _ => write!(f, "{:?}", self), // TODO(const_generics)`
`1293`	`1293`	`}`
`1294`	`1294`	`}`
`1295`	`1295`	`}`