Rename PrimVal to Scalar

10 files changed, 145 insertions, 145 deletions

diff --git a/src/librustc_mir/interpret/cast.rs b/src/librustc_mir/interpret/cast.rs
index b5568b83339..d8c5f80ebbc 100644
--- a/src/librustc_mir/interpret/cast.rs
+++ b/src/librustc_mir/interpret/cast.rs
@@ -4,23 +4,23 @@ use syntax::ast::{FloatTy, IntTy, UintTy};
 
 use rustc_apfloat::ieee::{Single, Double};
 use super::{EvalContext, Machine};
-use rustc::mir::interpret::{PrimVal, EvalResult, MemoryPointer, PointerArithmetic};
+use rustc::mir::interpret::{Scalar, EvalResult, MemoryPointer, PointerArithmetic};
 use rustc_apfloat::Float;
 
 impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
     pub(super) fn cast_primval(
         &self,
-        val: PrimVal,
+        val: Scalar,
         src_ty: Ty<'tcx>,
         dest_ty: Ty<'tcx>,
-    ) -> EvalResult<'tcx, PrimVal> {
+    ) -> EvalResult<'tcx, Scalar> {
         use rustc::ty::TypeVariants::*;
         trace!("Casting {:?}: {:?} to {:?}", val, src_ty, dest_ty);
 
         match val {
-            PrimVal::Undef => Ok(PrimVal::Undef),
-            PrimVal::Ptr(ptr) => self.cast_from_ptr(ptr, dest_ty),
-            PrimVal::Bytes(b) => {
+            Scalar::Undef => Ok(Scalar::Undef),
+            Scalar::Ptr(ptr) => self.cast_from_ptr(ptr, dest_ty),
+            Scalar::Bytes(b) => {
                 match src_ty.sty {
                     TyFloat(fty) => self.cast_from_float(b, fty, dest_ty),
                     _ => self.cast_from_int(b, src_ty, dest_ty),
@@ -34,7 +34,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
         v: u128,
         src_ty: Ty<'tcx>,
         dest_ty: Ty<'tcx>,
-    ) -> EvalResult<'tcx, PrimVal> {
+    ) -> EvalResult<'tcx, Scalar> {
         let signed = self.layout_of(src_ty)?.abi.is_signed();
         let v = if signed {
             self.sign_extend(v, src_ty)?
@@ -46,20 +46,20 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
         match dest_ty.sty {
             TyInt(_) | TyUint(_) => {
                 let v = self.truncate(v, dest_ty)?;
-                Ok(PrimVal::Bytes(v))
+                Ok(Scalar::Bytes(v))
             }
 
-            TyFloat(FloatTy::F32) if signed => Ok(PrimVal::Bytes(Single::from_i128(v as i128).value.to_bits())),
-            TyFloat(FloatTy::F64) if signed => Ok(PrimVal::Bytes(Double::from_i128(v as i128).value.to_bits())),
-            TyFloat(FloatTy::F32) => Ok(PrimVal::Bytes(Single::from_u128(v).value.to_bits())),
-            TyFloat(FloatTy::F64) => Ok(PrimVal::Bytes(Double::from_u128(v).value.to_bits())),
+            TyFloat(FloatTy::F32) if signed => Ok(Scalar::Bytes(Single::from_i128(v as i128).value.to_bits())),
+            TyFloat(FloatTy::F64) if signed => Ok(Scalar::Bytes(Double::from_i128(v as i128).value.to_bits())),
+            TyFloat(FloatTy::F32) => Ok(Scalar::Bytes(Single::from_u128(v).value.to_bits())),
+            TyFloat(FloatTy::F64) => Ok(Scalar::Bytes(Double::from_u128(v).value.to_bits())),
 
-            TyChar if v as u8 as u128 == v => Ok(PrimVal::Bytes(v)),
+            TyChar if v as u8 as u128 == v => Ok(Scalar::Bytes(v)),
             TyChar => err!(InvalidChar(v)),
 
             // No alignment check needed for raw pointers.  But we have to truncate to target ptr size.
             TyRawPtr(_) => {
-                Ok(PrimVal::Bytes(self.memory.truncate_to_ptr(v).0 as u128))
+                Ok(Scalar::Bytes(self.memory.truncate_to_ptr(v).0 as u128))
             },
 
             // Casts to bool are not permitted by rustc, no need to handle them here.
@@ -67,7 +67,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
         }
     }
 
-    fn cast_from_float(&self, bits: u128, fty: FloatTy, dest_ty: Ty<'tcx>) -> EvalResult<'tcx, PrimVal> {
+    fn cast_from_float(&self, bits: u128, fty: FloatTy, dest_ty: Ty<'tcx>) -> EvalResult<'tcx, Scalar> {
         use rustc::ty::TypeVariants::*;
         use rustc_apfloat::FloatConvert;
         match dest_ty.sty {
@@ -75,39 +75,39 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
             TyUint(t) => {
                 let width = t.bit_width().unwrap_or(self.memory.pointer_size().bytes() as usize * 8);
                 match fty {
-                    FloatTy::F32 => Ok(PrimVal::Bytes(Single::from_bits(bits).to_u128(width).value)),
-                    FloatTy::F64 => Ok(PrimVal::Bytes(Double::from_bits(bits).to_u128(width).value)),
+                    FloatTy::F32 => Ok(Scalar::Bytes(Single::from_bits(bits).to_u128(width).value)),
+                    FloatTy::F64 => Ok(Scalar::Bytes(Double::from_bits(bits).to_u128(width).value)),
                 }
             },
             // float -> int
             TyInt(t) => {
                 let width = t.bit_width().unwrap_or(self.memory.pointer_size().bytes() as usize * 8);
                 match fty {
-                    FloatTy::F32 => Ok(PrimVal::from_i128(Single::from_bits(bits).to_i128(width).value)),
-                    FloatTy::F64 => Ok(PrimVal::from_i128(Double::from_bits(bits).to_i128(width).value)),
+                    FloatTy::F32 => Ok(Scalar::from_i128(Single::from_bits(bits).to_i128(width).value)),
+                    FloatTy::F64 => Ok(Scalar::from_i128(Double::from_bits(bits).to_i128(width).value)),
                 }
             },
             // f64 -> f32
             TyFloat(FloatTy::F32) if fty == FloatTy::F64 => {
-                Ok(PrimVal::Bytes(Single::to_bits(Double::from_bits(bits).convert(&mut false).value)))
+                Ok(Scalar::Bytes(Single::to_bits(Double::from_bits(bits).convert(&mut false).value)))
             },
             // f32 -> f64
             TyFloat(FloatTy::F64) if fty == FloatTy::F32 => {
-                Ok(PrimVal::Bytes(Double::to_bits(Single::from_bits(bits).convert(&mut false).value)))
+                Ok(Scalar::Bytes(Double::to_bits(Single::from_bits(bits).convert(&mut false).value)))
             },
             // identity cast
-            TyFloat(_) => Ok(PrimVal::Bytes(bits)),
+            TyFloat(_) => Ok(Scalar::Bytes(bits)),
             _ => err!(Unimplemented(format!("float to {:?} cast", dest_ty))),
         }
     }
 
-    fn cast_from_ptr(&self, ptr: MemoryPointer, ty: Ty<'tcx>) -> EvalResult<'tcx, PrimVal> {
+    fn cast_from_ptr(&self, ptr: MemoryPointer, ty: Ty<'tcx>) -> EvalResult<'tcx, Scalar> {
         use rustc::ty::TypeVariants::*;
         match ty.sty {
             // Casting to a reference or fn pointer is not permitted by rustc, no need to support it here.
             TyRawPtr(_) |
             TyInt(IntTy::Isize) |
-            TyUint(UintTy::Usize) => Ok(PrimVal::Ptr(ptr)),
+            TyUint(UintTy::Usize) => Ok(Scalar::Ptr(ptr)),
             TyInt(_) | TyUint(_) => err!(ReadPointerAsBytes),
             _ => err!(Unimplemented(format!("ptr to {:?} cast", ty))),
         }
diff --git a/src/librustc_mir/interpret/const_eval.rs b/src/librustc_mir/interpret/const_eval.rs
index 1b4cde2f6ca..b4b072769ee 100644
--- a/src/librustc_mir/interpret/const_eval.rs
+++ b/src/librustc_mir/interpret/const_eval.rs
@@ -12,7 +12,7 @@ use syntax::codemap::DUMMY_SP;
 
 use rustc::mir::interpret::{
     EvalResult, EvalError, EvalErrorKind, GlobalId,
-    Value, Pointer, PrimVal, AllocId, Allocation, ConstValue,
+    Value, Pointer, Scalar, AllocId, Allocation, ConstValue,
 };
 use super::{Place, EvalContext, StackPopCleanup, ValTy, PlaceExtra, Memory, MemoryKind};
 
@@ -100,7 +100,7 @@ pub fn value_to_const_value<'tcx>(
 ) -> &'tcx ty::Const<'tcx> {
     let layout = ecx.tcx.layout_of(ty::ParamEnv::reveal_all().and(ty)).unwrap();
     match (val, &layout.abi) {
-        (Value::ByVal(PrimVal::Undef), _) if layout.is_zst() => {},
+        (Value::ByVal(Scalar::Undef), _) if layout.is_zst() => {},
         (Value::ByRef(..), _) |
         (Value::ByVal(_), &layout::Abi::Scalar(_)) |
         (Value::ByValPair(..), &layout::Abi::ScalarPair(..)) => {},
@@ -319,20 +319,20 @@ impl<'mir, 'tcx> super::Machine<'mir, 'tcx> for CompileTimeEvaluator {
             "min_align_of" => {
                 let elem_ty = substs.type_at(0);
                 let elem_align = ecx.layout_of(elem_ty)?.align.abi();
-                let align_val = PrimVal::from_u128(elem_align as u128);
+                let align_val = Scalar::from_u128(elem_align as u128);
                 ecx.write_primval(dest, align_val, dest_layout.ty)?;
             }
 
             "size_of" => {
                 let ty = substs.type_at(0);
                 let size = ecx.layout_of(ty)?.size.bytes() as u128;
-                ecx.write_primval(dest, PrimVal::from_u128(size), dest_layout.ty)?;
+                ecx.write_primval(dest, Scalar::from_u128(size), dest_layout.ty)?;
             }
 
             "type_id" => {
                 let ty = substs.type_at(0);
                 let type_id = ecx.tcx.type_id_hash(ty) as u128;
-                ecx.write_primval(dest, PrimVal::from_u128(type_id), dest_layout.ty)?;
+                ecx.write_primval(dest, Scalar::from_u128(type_id), dest_layout.ty)?;
             }
 
             name => return Err(ConstEvalError::NeedsRfc(format!("calling intrinsic `{}`", name)).into()),
@@ -349,11 +349,11 @@ impl<'mir, 'tcx> super::Machine<'mir, 'tcx> for CompileTimeEvaluator {
     fn try_ptr_op<'a>(
         _ecx: &EvalContext<'a, 'mir, 'tcx, Self>,
         _bin_op: mir::BinOp,
-        left: PrimVal,
+        left: Scalar,
         _left_ty: Ty<'tcx>,
-        right: PrimVal,
+        right: Scalar,
         _right_ty: Ty<'tcx>,
-    ) -> EvalResult<'tcx, Option<(PrimVal, bool)>> {
+    ) -> EvalResult<'tcx, Option<(Scalar, bool)>> {
         if left.is_bytes() && right.is_bytes() {
             Ok(None)
         } else {
diff --git a/src/librustc_mir/interpret/eval_context.rs b/src/librustc_mir/interpret/eval_context.rs
index 7d10643e81e..b21c5d186cf 100644
--- a/src/librustc_mir/interpret/eval_context.rs
+++ b/src/librustc_mir/interpret/eval_context.rs
@@ -14,7 +14,7 @@ use rustc::middle::const_val::FrameInfo;
 use syntax::codemap::{self, Span};
 use syntax::ast::Mutability;
 use rustc::mir::interpret::{
-    GlobalId, Value, Pointer, PrimVal, PrimValKind,
+    GlobalId, Value, Pointer, Scalar, ScalarKind,
     EvalError, EvalResult, EvalErrorKind, MemoryPointer, ConstValue,
 };
 use std::mem;
@@ -74,9 +74,9 @@ pub struct Frame<'mir, 'tcx: 'mir> {
     /// The list of locals for this stack frame, stored in order as
     /// `[return_ptr, arguments..., variables..., temporaries...]`. The locals are stored as `Option<Value>`s.
     /// `None` represents a local that is currently dead, while a live local
-    /// can either directly contain `PrimVal` or refer to some part of an `Allocation`.
+    /// can either directly contain `Scalar` or refer to some part of an `Allocation`.
     ///
-    /// Before being initialized, arguments are `Value::ByVal(PrimVal::Undef)` and other locals are `None`.
+    /// Before being initialized, arguments are `Value::ByVal(Scalar::Undef)` and other locals are `None`.
     pub locals: IndexVec<mir::Local, Option<Value>>,
 
     ////////////////////////////////////////////////////////////////////////////////
@@ -231,8 +231,8 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
     pub fn str_to_value(&mut self, s: &str) -> EvalResult<'tcx, Value> {
         let ptr = self.memory.allocate_bytes(s.as_bytes());
         Ok(Value::ByValPair(
-            PrimVal::Ptr(ptr),
-            PrimVal::from_u128(s.len() as u128),
+            Scalar::Ptr(ptr),
+            Scalar::from_u128(s.len() as u128),
         ))
     }
 
@@ -408,7 +408,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
         ::log_settings::settings().indentation += 1;
 
         let locals = if mir.local_decls.len() > 1 {
-            let mut locals = IndexVec::from_elem(Some(Value::ByVal(PrimVal::Undef)), &mir.local_decls);
+            let mut locals = IndexVec::from_elem(Some(Value::ByVal(Scalar::Undef)), &mir.local_decls);
             match self.tcx.describe_def(instance.def_id()) {
                 // statics and constants don't have `Storage*` statements, no need to look for them
                 Some(Def::Static(..)) | Some(Def::Const(..)) | Some(Def::AssociatedConst(..)) => {},
@@ -608,7 +608,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
                 let (_, len) = src.elem_ty_and_len(ty, self.tcx.tcx);
                 self.write_primval(
                     dest,
-                    PrimVal::from_u128(len as u128),
+                    Scalar::from_u128(len as u128),
                     dest_ty,
                 )?;
             }
@@ -646,7 +646,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
                         "SizeOf nullary MIR operator called for unsized type");
                 self.write_primval(
                     dest,
-                    PrimVal::from_u128(layout.size.bytes() as u128),
+                    Scalar::from_u128(layout.size.bytes() as u128),
                     dest_ty,
                 )?;
             }
@@ -696,7 +696,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
                                             .val;
                                         return self.write_primval(
                                             dest,
-                                            PrimVal::Bytes(discr_val),
+                                            Scalar::Bytes(discr_val),
                                             dest_ty);
                                     }
                                 }
@@ -729,7 +729,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
                                 ).ok_or_else(|| EvalErrorKind::TypeckError.into());
                                 let fn_ptr = self.memory.create_fn_alloc(instance?);
                                 let valty = ValTy {
-                                    value: Value::ByVal(PrimVal::Ptr(fn_ptr)),
+                                    value: Value::ByVal(Scalar::Ptr(fn_ptr)),
                                     ty: dest_ty,
                                 };
                                 self.write_value(valty, dest)?;
@@ -765,7 +765,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
                                 );
                                 let fn_ptr = self.memory.create_fn_alloc(instance);
                                 let valty = ValTy {
-                                    value: Value::ByVal(PrimVal::Ptr(fn_ptr)),
+                                    value: Value::ByVal(Scalar::Ptr(fn_ptr)),
                                     ty: dest_ty,
                                 };
                                 self.write_value(valty, dest)?;
@@ -780,7 +780,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
                 let ty = self.place_ty(place);
                 let place = self.eval_place(place)?;
                 let discr_val = self.read_discriminant_value(place, ty)?;
-                self.write_primval(dest, PrimVal::Bytes(discr_val), dest_ty)?;
+                self.write_primval(dest, Scalar::Bytes(discr_val), dest_ty)?;
             }
         }
 
@@ -801,7 +801,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
     pub(super) fn eval_operand_to_primval(
         &mut self,
         op: &mir::Operand<'tcx>,
-    ) -> EvalResult<'tcx, PrimVal> {
+    ) -> EvalResult<'tcx, Scalar> {
         let valty = self.eval_operand(op)?;
         self.value_to_primval(valty)
     }
@@ -937,12 +937,12 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
                 let variants_start = *niche_variants.start() as u128;
                 let variants_end = *niche_variants.end() as u128;
                 match raw_discr {
-                    PrimVal::Ptr(_) => {
+                    Scalar::Ptr(_) => {
                         assert!(niche_start == 0);
                         assert!(variants_start == variants_end);
                         dataful_variant as u128
                     },
-                    PrimVal::Bytes(raw_discr) => {
+                    Scalar::Bytes(raw_discr) => {
                         let discr = raw_discr.wrapping_sub(niche_start)
                             .wrapping_add(variants_start);
                         if variants_start <= discr && discr <= variants_end {
@@ -951,7 +951,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
                             dataful_variant as u128
                         }
                     },
-                    PrimVal::Undef => return err!(ReadUndefBytes),
+                    Scalar::Undef => return err!(ReadUndefBytes),
                 }
             }
         };
@@ -990,7 +990,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
                 let discr_val = (discr_val << amt) >> amt;
 
                 let (discr_dest, tag) = self.place_field(dest, mir::Field::new(0), layout)?;
-                self.write_primval(discr_dest, PrimVal::Bytes(discr_val), tag.ty)?;
+                self.write_primval(discr_dest, Scalar::Bytes(discr_val), tag.ty)?;
             }
             layout::Variants::NicheFilling {
                 dataful_variant,
@@ -1003,7 +1003,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
                         self.place_field(dest, mir::Field::new(0), layout)?;
                     let niche_value = ((variant_index - niche_variants.start()) as u128)
                         .wrapping_add(niche_start);
-                    self.write_primval(niche_dest, PrimVal::Bytes(niche_value), niche.ty)?;
+                    self.write_primval(niche_dest, Scalar::Bytes(niche_value), niche.ty)?;
                 }
             }
         }
@@ -1090,7 +1090,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
     pub fn value_to_primval(
         &self,
         ValTy { value, ty } : ValTy<'tcx>,
-    ) -> EvalResult<'tcx, PrimVal> {
+    ) -> EvalResult<'tcx, Scalar> {
         match self.follow_by_ref_value(value, ty)? {
             Value::ByRef { .. } => bug!("follow_by_ref_value can't result in `ByRef`"),
 
@@ -1115,7 +1115,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
     pub fn write_primval(
         &mut self,
         dest: Place,
-        val: PrimVal,
+        val: Scalar,
         dest_ty: Ty<'tcx>,
     ) -> EvalResult<'tcx> {
         let valty = ValTy {
@@ -1239,12 +1239,12 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
         }
     }
 
-    pub fn ty_to_primval_kind(&self, ty: Ty<'tcx>) -> EvalResult<'tcx, PrimValKind> {
+    pub fn ty_to_primval_kind(&self, ty: Ty<'tcx>) -> EvalResult<'tcx, ScalarKind> {
         use syntax::ast::FloatTy;
 
         let kind = match ty.sty {
-            ty::TyBool => PrimValKind::Bool,
-            ty::TyChar => PrimValKind::Char,
+            ty::TyBool => ScalarKind::Bool,
+            ty::TyChar => ScalarKind::Char,
 
             ty::TyInt(int_ty) => {
                 use syntax::ast::IntTy::*;
@@ -1256,7 +1256,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
                     I128 => Size::from_bytes(16),
                     Isize => self.memory.pointer_size(),
                 };
-                PrimValKind::from_int_size(size)
+                ScalarKind::from_int_size(size)
             }
 
             ty::TyUint(uint_ty) => {
@@ -1269,31 +1269,31 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
                     U128 => Size::from_bytes(16),
                     Usize => self.memory.pointer_size(),
                 };
-                PrimValKind::from_uint_size(size)
+                ScalarKind::from_uint_size(size)
             }
 
-            ty::TyFloat(FloatTy::F32) => PrimValKind::F32,
-            ty::TyFloat(FloatTy::F64) => PrimValKind::F64,
+            ty::TyFloat(FloatTy::F32) => ScalarKind::F32,
+            ty::TyFloat(FloatTy::F64) => ScalarKind::F64,
 
-            ty::TyFnPtr(_) => PrimValKind::FnPtr,
+            ty::TyFnPtr(_) => ScalarKind::FnPtr,
 
             ty::TyRef(_, ty, _) |
             ty::TyRawPtr(ty::TypeAndMut { ty, .. }) if self.type_is_sized(ty) => {
-                PrimValKind::Ptr
+                ScalarKind::Ptr
             }
 
-            ty::TyAdt(def, _) if def.is_box() => PrimValKind::Ptr,
+            ty::TyAdt(def, _) if def.is_box() => ScalarKind::Ptr,
 
             ty::TyAdt(..) => {
                 match self.layout_of(ty)?.abi {
                     layout::Abi::Scalar(ref scalar) => {
                         use rustc::ty::layout::Primitive::*;
                         match scalar.value {
-                            Int(i, false) => PrimValKind::from_uint_size(i.size()),
-                            Int(i, true) => PrimValKind::from_int_size(i.size()),
-                            F32 => PrimValKind::F32,
-                            F64 => PrimValKind::F64,
-                            Pointer => PrimValKind::Ptr,
+                            Int(i, false) => ScalarKind::from_uint_size(i.size()),
+                            Int(i, true) => ScalarKind::from_int_size(i.size()),
+                            F32 => ScalarKind::F32,
+                            F64 => ScalarKind::F64,
+                            Pointer => ScalarKind::Ptr,
                         }
                     }
 
@@ -1307,7 +1307,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
         Ok(kind)
     }
 
-    fn ensure_valid_value(&self, val: PrimVal, ty: Ty<'tcx>) -> EvalResult<'tcx> {
+    fn ensure_valid_value(&self, val: Scalar, ty: Ty<'tcx>) -> EvalResult<'tcx> {
         match ty.sty {
             ty::TyBool if val.to_bytes()? > 1 => err!(InvalidBool),
 
@@ -1366,7 +1366,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
             ty::TyBool => {
                 let val = self.memory.read_primval(ptr, ptr_align, Size::from_bytes(1))?;
                 match val {
-                    PrimVal::Bytes(0) | PrimVal::Bytes(1) => (),
+                    Scalar::Bytes(0) | Scalar::Bytes(1) => (),
                     // TODO: This seems a little overeager, should reading at bool type already be insta-UB?
                     _ => return err!(InvalidBool),
                 }
@@ -1419,7 +1419,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
         self.memory.check_align(ptr, ptr_align)?;
 
         if layout.size.bytes() == 0 {
-            return Ok(Some(Value::ByVal(PrimVal::Undef)));
+            return Ok(Some(Value::ByVal(Scalar::Undef)));
         }
 
         let ptr = ptr.to_ptr()?;
@@ -1615,7 +1615,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
                     }
                     Ok(Value::ByRef(ptr, align)) => {
                         match ptr.into_inner_primval() {
-                            PrimVal::Ptr(ptr) => {
+                            Scalar::Ptr(ptr) => {
                                 write!(msg, " by align({}) ref:", align.abi()).unwrap();
                                 allocs.push(ptr.alloc_id);
                             }
@@ -1624,16 +1624,16 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
                     }
                     Ok(Value::ByVal(val)) => {
                         write!(msg, " {:?}", val).unwrap();
-                        if let PrimVal::Ptr(ptr) = val {
+                        if let Scalar::Ptr(ptr) = val {
                             allocs.push(ptr.alloc_id);
                         }
                     }
                     Ok(Value::ByValPair(val1, val2)) => {
                         write!(msg, " ({:?}, {:?})", val1, val2).unwrap();
-                        if let PrimVal::Ptr(ptr) = val1 {
+                        if let Scalar::Ptr(ptr) = val1 {
                             allocs.push(ptr.alloc_id);
                         }
-                        if let PrimVal::Ptr(ptr) = val2 {
+                        if let Scalar::Ptr(ptr) = val2 {
                             allocs.push(ptr.alloc_id);
                         }
                     }
@@ -1644,7 +1644,7 @@ impl<'a, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M
             }
             Place::Ptr { ptr, align, .. } => {
                 match ptr.into_inner_primval() {
-                    PrimVal::Ptr(ptr) => {
+                    Scalar::Ptr(ptr) => {
                         trace!("by align({}) ref:", align.abi());
                         self.memory.dump_alloc(ptr.alloc_id);
                     }
@@ -1797,7 +1797,7 @@ impl<'mir, 'tcx> Frame<'mir, 'tcx> {
         trace!("{:?} is now live", local);
 
         // StorageLive *always* kills the value that's currently stored
-        mem::replace(&mut self.locals[local], Some(Value::ByVal(PrimVal::Undef)))
+        mem::replace(&mut self.locals[local], Some(Value::ByVal(Scalar::Undef)))
     }
 
     /// Returns the old value of the local
diff --git a/src/librustc_mir/interpret/machine.rs b/src/librustc_mir/interpret/machine.rs
index a5c94e4fcec..3054bbd1d77 100644
--- a/src/librustc_mir/interpret/machine.rs
+++ b/src/librustc_mir/interpret/machine.rs
@@ -2,7 +2,7 @@
 //! This separation exists to ensure that no fancy miri features like
 //! interpreting common C functions leak into CTFE.
 
-use rustc::mir::interpret::{AllocId, EvalResult, PrimVal, MemoryPointer, AccessKind, GlobalId};
+use rustc::mir::interpret::{AllocId, EvalResult, Scalar, MemoryPointer, AccessKind, GlobalId};
 use super::{EvalContext, Place, ValTy, Memory};
 
 use rustc::mir;
@@ -54,11 +54,11 @@ pub trait Machine<'mir, 'tcx>: Sized {
     fn try_ptr_op<'a>(
         ecx: &EvalContext<'a, 'mir, 'tcx, Self>,
         bin_op: mir::BinOp,
-        left: PrimVal,
+        left: Scalar,
         left_ty: Ty<'tcx>,
-        right: PrimVal,
+        right: Scalar,
         right_ty: Ty<'tcx>,
-    ) -> EvalResult<'tcx, Option<(PrimVal, bool)>>;
+    ) -> EvalResult<'tcx, Option<(Scalar, bool)>>;
 
     /// Called when trying to mark machine defined `MemoryKinds` as static
     fn mark_static_initialized<'a>(
diff --git a/src/librustc_mir/interpret/memory.rs b/src/librustc_mir/interpret/memory.rs
index 2eef8c73db8..589ef4f1d2c 100644
--- a/src/librustc_mir/interpret/memory.rs
+++ b/src/librustc_mir/interpret/memory.rs
@@ -11,7 +11,7 @@ use rustc::middle::const_val::{ConstVal, ErrKind};
 
 use rustc_data_structures::fx::{FxHashSet, FxHashMap};
 use rustc::mir::interpret::{MemoryPointer, AllocId, Allocation, AccessKind, Value, Pointer,
-                            EvalResult, PrimVal, EvalErrorKind, GlobalId, AllocType};
+                            EvalResult, Scalar, EvalErrorKind, GlobalId, AllocType};
 pub use rustc::mir::interpret::{write_target_uint, write_target_int, read_target_uint};
 
 use super::{EvalContext, Machine};
@@ -231,11 +231,11 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'a, 'mir, 'tcx, M> {
     pub fn check_align(&self, ptr: Pointer, required_align: Align) -> EvalResult<'tcx> {
         // Check non-NULL/Undef, extract offset
         let (offset, alloc_align) = match ptr.into_inner_primval() {
-            PrimVal::Ptr(ptr) => {
+            Scalar::Ptr(ptr) => {
                 let alloc = self.get(ptr.alloc_id)?;
                 (ptr.offset.bytes(), alloc.align)
             }
-            PrimVal::Bytes(bytes) => {
+            Scalar::Bytes(bytes) => {
                 let v = ((bytes as u128) % (1 << self.pointer_size().bytes())) as u64;
                 if v == 0 {
                     return err!(InvalidNullPointerUsage);
@@ -243,7 +243,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'a, 'mir, 'tcx, M> {
                 // the base address if the "integer allocation" is 0 and hence always aligned
                 (v, required_align)
             }
-            PrimVal::Undef => return err!(ReadUndefBytes),
+            Scalar::Undef => return err!(ReadUndefBytes),
         };
         // Check alignment
         if alloc_align.abi() < required_align.abi() {
@@ -707,14 +707,14 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'a, 'mir, 'tcx, M> {
         Ok(())
     }
 
-    pub fn read_primval(&self, ptr: MemoryPointer, ptr_align: Align, size: Size) -> EvalResult<'tcx, PrimVal> {
+    pub fn read_primval(&self, ptr: MemoryPointer, ptr_align: Align, size: Size) -> EvalResult<'tcx, Scalar> {
         self.check_relocation_edges(ptr, size)?; // Make sure we don't read part of a pointer as a pointer
         let endianness = self.endianness();
         let bytes = self.get_bytes_unchecked(ptr, size, ptr_align.min(self.int_align(size)))?;
         // Undef check happens *after* we established that the alignment is correct.
         // We must not return Ok() for unaligned pointers!
         if self.check_defined(ptr, size).is_err() {
-            return Ok(PrimVal::Undef.into());
+            return Ok(Scalar::Undef.into());
         }
         // Now we do the actual reading
         let bytes = read_target_uint(endianness, bytes).unwrap();
@@ -726,30 +726,30 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'a, 'mir, 'tcx, M> {
         } else {
             let alloc = self.get(ptr.alloc_id)?;
             match alloc.relocations.get(&ptr.offset) {
-                Some(&alloc_id) => return Ok(PrimVal::Ptr(MemoryPointer::new(alloc_id, Size::from_bytes(bytes as u64)))),
+                Some(&alloc_id) => return Ok(Scalar::Ptr(MemoryPointer::new(alloc_id, Size::from_bytes(bytes as u64)))),
                 None => {},
             }
         }
         // We don't. Just return the bytes.
-        Ok(PrimVal::Bytes(bytes))
+        Ok(Scalar::Bytes(bytes))
     }
 
-    pub fn read_ptr_sized(&self, ptr: MemoryPointer, ptr_align: Align) -> EvalResult<'tcx, PrimVal> {
+    pub fn read_ptr_sized(&self, ptr: MemoryPointer, ptr_align: Align) -> EvalResult<'tcx, Scalar> {
         self.read_primval(ptr, ptr_align, self.pointer_size())
     }
 
-    pub fn write_primval(&mut self, ptr: Pointer, ptr_align: Align, val: PrimVal, size: Size, signed: bool) -> EvalResult<'tcx> {
+    pub fn write_primval(&mut self, ptr: Pointer, ptr_align: Align, val: Scalar, size: Size, signed: bool) -> EvalResult<'tcx> {
         let endianness = self.endianness();
 
         let bytes = match val {
-            PrimVal::Ptr(val) => {
+            Scalar::Ptr(val) => {
                 assert_eq!(size, self.pointer_size());
                 val.offset.bytes() as u128
             }
 
-            PrimVal::Bytes(bytes) => bytes,
+            Scalar::Bytes(bytes) => bytes,
 
-            PrimVal::Undef => {
+            Scalar::Undef => {
                 self.check_align(ptr.into(), ptr_align)?;
                 self.mark_definedness(ptr, size, false)?;
                 return Ok(());
@@ -770,7 +770,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'a, 'mir, 'tcx, M> {
 
         // See if we have to also write a relocation
         match val {
-            PrimVal::Ptr(val) => {
+            Scalar::Ptr(val) => {
                 self.get_mut(ptr.alloc_id)?.relocations.insert(
                     ptr.offset,
                     val.alloc_id,
@@ -782,7 +782,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'a, 'mir, 'tcx, M> {
         Ok(())
     }
 
-    pub fn write_ptr_sized_unsigned(&mut self, ptr: MemoryPointer, ptr_align: Align, val: PrimVal) -> EvalResult<'tcx> {
+    pub fn write_ptr_sized_unsigned(&mut self, ptr: MemoryPointer, ptr_align: Align, val: Scalar) -> EvalResult<'tcx> {
         let ptr_size = self.pointer_size();
         self.write_primval(ptr.into(), ptr_align, val, ptr_size, false)
     }
@@ -954,7 +954,7 @@ pub trait HasMemory<'a, 'mir, 'tcx: 'a + 'mir, M: Machine<'mir, 'tcx>> {
 
             Value::ByValPair(ptr, vtable) => Ok((ptr.into(), vtable.to_ptr()?)),
 
-            Value::ByVal(PrimVal::Undef) => err!(ReadUndefBytes),
+            Value::ByVal(Scalar::Undef) => err!(ReadUndefBytes),
             _ => bug!("expected ptr and vtable, got {:?}", value),
         }
     }
@@ -978,7 +978,7 @@ pub trait HasMemory<'a, 'mir, 'tcx: 'a + 'mir, M: Machine<'mir, 'tcx>> {
                 assert_eq!(len as u64 as u128, len);
                 Ok((ptr.into(), len as u64))
             }
-            Value::ByVal(PrimVal::Undef) => err!(ReadUndefBytes),
+            Value::ByVal(Scalar::Undef) => err!(ReadUndefBytes),
             Value::ByVal(_) => bug!("expected ptr and length, got {:?}", value),
         }
     }
diff --git a/src/librustc_mir/interpret/operator.rs b/src/librustc_mir/interpret/operator.rs
index a4a36b0b355..eece3ec6f05 100644
--- a/src/librustc_mir/interpret/operator.rs
+++ b/src/librustc_mir/interpret/operator.rs
@@ -7,7 +7,7 @@ use rustc_apfloat::Float;
 
 use super::{EvalContext, Place, Machine, ValTy};
 
-use rustc::mir::interpret::{EvalResult, PrimVal, Value};
+use rustc::mir::interpret::{EvalResult, Scalar, Value};
 
 impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
     fn binop_with_overflow(
@@ -15,7 +15,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
         op: mir::BinOp,
         left: ValTy<'tcx>,
         right: ValTy<'tcx>,
-    ) -> EvalResult<'tcx, (PrimVal, bool)> {
+    ) -> EvalResult<'tcx, (Scalar, bool)> {
         let left_val = self.value_to_primval(left)?;
         let right_val = self.value_to_primval(right)?;
         self.binary_op(op, left_val, left.ty, right_val, right.ty)
@@ -32,7 +32,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
         dest_ty: Ty<'tcx>,
     ) -> EvalResult<'tcx> {
         let (val, overflowed) = self.binop_with_overflow(op, left, right)?;
-        let val = Value::ByValPair(val, PrimVal::from_bool(overflowed));
+        let val = Value::ByValPair(val, Scalar::from_bool(overflowed));
         let valty = ValTy {
             value: val,
             ty: dest_ty,
@@ -61,11 +61,11 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
     pub fn binary_op(
         &self,
         bin_op: mir::BinOp,
-        left: PrimVal,
+        left: Scalar,
         left_ty: Ty<'tcx>,
-        right: PrimVal,
+        right: Scalar,
         right_ty: Ty<'tcx>,
-    ) -> EvalResult<'tcx, (PrimVal, bool)> {
+    ) -> EvalResult<'tcx, (Scalar, bool)> {
         use rustc::mir::BinOp::*;
 
         let left_kind = self.ty_to_primval_kind(left_ty)?;
@@ -110,7 +110,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
                 }
             };
             let truncated = self.truncate(result, left_ty)?;
-            return Ok((PrimVal::Bytes(truncated), oflo));
+            return Ok((Scalar::Bytes(truncated), oflo));
         }
 
         if left_kind != right_kind {
@@ -136,7 +136,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
             if let Some(op) = op {
                 let l = self.sign_extend(l, left_ty)? as i128;
                 let r = self.sign_extend(r, right_ty)? as i128;
-                return Ok((PrimVal::from_bool(op(&l, &r)), false));
+                return Ok((Scalar::from_bool(op(&l, &r)), false));
             }
             let op: Option<fn(i128, i128) -> (i128, bool)> = match bin_op {
                 Div if r == 0 => return err!(DivisionByZero),
@@ -156,7 +156,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
                     Rem | Div => {
                         // int_min / -1
                         if r == -1 && l == (1 << (size - 1)) {
-                            return Ok((PrimVal::Bytes(l), true));
+                            return Ok((Scalar::Bytes(l), true));
                         }
                     },
                     _ => {},
@@ -170,7 +170,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
                 }
                 let result = result as u128;
                 let truncated = self.truncate(result, left_ty)?;
-                return Ok((PrimVal::Bytes(truncated), oflo));
+                return Ok((Scalar::Bytes(truncated), oflo));
             }
         }
 
@@ -180,17 +180,17 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
                     let l = <$ty>::from_bits(l);
                     let r = <$ty>::from_bits(r);
                     let val = match bin_op {
-                        Eq => PrimVal::from_bool(l == r),
-                        Ne => PrimVal::from_bool(l != r),
-                        Lt => PrimVal::from_bool(l < r),
-                        Le => PrimVal::from_bool(l <= r),
-                        Gt => PrimVal::from_bool(l > r),
-                        Ge => PrimVal::from_bool(l >= r),
-                        Add => PrimVal::Bytes((l + r).value.to_bits()),
-                        Sub => PrimVal::Bytes((l - r).value.to_bits()),
-                        Mul => PrimVal::Bytes((l * r).value.to_bits()),
-                        Div => PrimVal::Bytes((l / r).value.to_bits()),
-                        Rem => PrimVal::Bytes((l % r).value.to_bits()),
+                        Eq => Scalar::from_bool(l == r),
+                        Ne => Scalar::from_bool(l != r),
+                        Lt => Scalar::from_bool(l < r),
+                        Le => Scalar::from_bool(l <= r),
+                        Gt => Scalar::from_bool(l > r),
+                        Ge => Scalar::from_bool(l >= r),
+                        Add => Scalar::Bytes((l + r).value.to_bits()),
+                        Sub => Scalar::Bytes((l - r).value.to_bits()),
+                        Mul => Scalar::Bytes((l * r).value.to_bits()),
+                        Div => Scalar::Bytes((l / r).value.to_bits()),
+                        Rem => Scalar::Bytes((l % r).value.to_bits()),
                         _ => bug!("invalid float op: `{:?}`", bin_op),
                     };
                     return Ok((val, false));
@@ -204,17 +204,17 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
 
         // only ints left
         let val = match bin_op {
-            Eq => PrimVal::from_bool(l == r),
-            Ne => PrimVal::from_bool(l != r),
+            Eq => Scalar::from_bool(l == r),
+            Ne => Scalar::from_bool(l != r),
 
-            Lt => PrimVal::from_bool(l < r),
-            Le => PrimVal::from_bool(l <= r),
-            Gt => PrimVal::from_bool(l > r),
-            Ge => PrimVal::from_bool(l >= r),
+            Lt => Scalar::from_bool(l < r),
+            Le => Scalar::from_bool(l <= r),
+            Gt => Scalar::from_bool(l > r),
+            Ge => Scalar::from_bool(l >= r),
 
-            BitOr => PrimVal::Bytes(l | r),
-            BitAnd => PrimVal::Bytes(l & r),
-            BitXor => PrimVal::Bytes(l ^ r),
+            BitOr => Scalar::Bytes(l | r),
+            BitAnd => Scalar::Bytes(l & r),
+            BitXor => Scalar::Bytes(l ^ r),
 
             Add | Sub | Mul | Rem | Div => {
                 let op: fn(u128, u128) -> (u128, bool) = match bin_op {
@@ -229,7 +229,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
                 };
                 let (result, oflo) = op(l, r);
                 let truncated = self.truncate(result, left_ty)?;
-                return Ok((PrimVal::Bytes(truncated), oflo || truncated != result));
+                return Ok((Scalar::Bytes(truncated), oflo || truncated != result));
             }
 
             _ => {
@@ -251,9 +251,9 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
     pub fn unary_op(
         &self,
         un_op: mir::UnOp,
-        val: PrimVal,
+        val: Scalar,
         ty: Ty<'tcx>,
-    ) -> EvalResult<'tcx, PrimVal> {
+    ) -> EvalResult<'tcx, Scalar> {
         use rustc::mir::UnOp::*;
         use rustc_apfloat::ieee::{Single, Double};
         use rustc_apfloat::Float;
@@ -274,6 +274,6 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
             (Neg, _) => (-(bytes as i128)) as u128,
         };
 
-        Ok(PrimVal::Bytes(self.truncate(result_bytes, ty)?))
+        Ok(Scalar::Bytes(self.truncate(result_bytes, ty)?))
     }
 }
diff --git a/src/librustc_mir/interpret/place.rs b/src/librustc_mir/interpret/place.rs
index 6b5ad615654..c0586cde4eb 100644
--- a/src/librustc_mir/interpret/place.rs
+++ b/src/librustc_mir/interpret/place.rs
@@ -3,7 +3,7 @@ use rustc::ty::{self, Ty, TyCtxt};
 use rustc::ty::layout::{self, Align, LayoutOf, TyLayout};
 use rustc_data_structures::indexed_vec::Idx;
 
-use rustc::mir::interpret::{GlobalId, Value, PrimVal, EvalResult, Pointer, MemoryPointer};
+use rustc::mir::interpret::{GlobalId, Value, Scalar, EvalResult, Pointer, MemoryPointer};
 use super::{EvalContext, Machine, ValTy};
 use interpret::memory::HasMemory;
 
@@ -35,7 +35,7 @@ pub enum PlaceExtra {
 impl<'tcx> Place {
     /// Produces a Place that will error if attempted to be read from
     pub fn undef() -> Self {
-        Self::from_primval_ptr(PrimVal::Undef.into(), Align::from_bytes(1, 1).unwrap())
+        Self::from_primval_ptr(Scalar::Undef.into(), Align::from_bytes(1, 1).unwrap())
     }
 
     pub fn from_primval_ptr(ptr: Pointer, align: Align) -> Self {
@@ -128,7 +128,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
         let field_index = field.index();
         let field = base_layout.field(self, field_index)?;
         if field.size.bytes() == 0 {
-            return Ok(Some((Value::ByVal(PrimVal::Undef), field.ty)))
+            return Ok(Some((Value::ByVal(Scalar::Undef), field.ty)))
         }
         let offset = base_layout.fields.offset(field_index);
         match base {
diff --git a/src/librustc_mir/interpret/terminator/drop.rs b/src/librustc_mir/interpret/terminator/drop.rs
index fbc0c499e59..aebf5cdfda5 100644
--- a/src/librustc_mir/interpret/terminator/drop.rs
+++ b/src/librustc_mir/interpret/terminator/drop.rs
@@ -2,7 +2,7 @@ use rustc::mir::BasicBlock;
 use rustc::ty::{self, Ty};
 use syntax::codemap::Span;
 
-use rustc::mir::interpret::{EvalResult, PrimVal, Value};
+use rustc::mir::interpret::{EvalResult, Scalar, Value};
 use interpret::{Machine, ValTy, EvalContext, Place, PlaceExtra};
 
 impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
@@ -52,7 +52,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
         let instance = match ty.sty {
             ty::TyDynamic(..) => {
                 let vtable = match arg {
-                    Value::ByValPair(_, PrimVal::Ptr(vtable)) => vtable,
+                    Value::ByValPair(_, Scalar::Ptr(vtable)) => vtable,
                     _ => bug!("expected fat ptr, got {:?}", arg),
                 };
                 match self.read_drop_type_from_vtable(vtable)? {
diff --git a/src/librustc_mir/interpret/terminator/mod.rs b/src/librustc_mir/interpret/terminator/mod.rs
index c5b823ca87b..3fe7cbffdb0 100644
--- a/src/librustc_mir/interpret/terminator/mod.rs
+++ b/src/librustc_mir/interpret/terminator/mod.rs
@@ -4,7 +4,7 @@ use rustc::ty::layout::LayoutOf;
 use syntax::codemap::Span;
 use rustc_target::spec::abi::Abi;
 
-use rustc::mir::interpret::{EvalResult, PrimVal, Value};
+use rustc::mir::interpret::{EvalResult, Scalar, Value};
 use super::{EvalContext, Place, Machine, ValTy};
 
 use rustc_data_structures::indexed_vec::Idx;
@@ -359,7 +359,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
                                             self.write_value(valty, dest)?;
                                         }
                                     }
-                                    Value::ByVal(PrimVal::Undef) => {}
+                                    Value::ByVal(Scalar::Undef) => {}
                                     other => {
                                         trace!("{:#?}, {:#?}", other, layout);
                                         let mut layout = layout;
diff --git a/src/librustc_mir/interpret/traits.rs b/src/librustc_mir/interpret/traits.rs
index ded27108e71..70b8094ab91 100644
--- a/src/librustc_mir/interpret/traits.rs
+++ b/src/librustc_mir/interpret/traits.rs
@@ -2,7 +2,7 @@ use rustc::ty::{self, Ty};
 use rustc::ty::layout::{Size, Align, LayoutOf};
 use syntax::ast::Mutability;
 
-use rustc::mir::interpret::{PrimVal, Value, MemoryPointer, EvalResult};
+use rustc::mir::interpret::{Scalar, Value, MemoryPointer, EvalResult};
 use super::{EvalContext, Machine};
 
 impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
@@ -35,19 +35,19 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
 
         let drop = ::monomorphize::resolve_drop_in_place(*self.tcx, ty);
         let drop = self.memory.create_fn_alloc(drop);
-        self.memory.write_ptr_sized_unsigned(vtable, ptr_align, PrimVal::Ptr(drop))?;
+        self.memory.write_ptr_sized_unsigned(vtable, ptr_align, Scalar::Ptr(drop))?;
 
         let size_ptr = vtable.offset(ptr_size, &self)?;
-        self.memory.write_ptr_sized_unsigned(size_ptr, ptr_align, PrimVal::Bytes(size as u128))?;
+        self.memory.write_ptr_sized_unsigned(size_ptr, ptr_align, Scalar::Bytes(size as u128))?;
         let align_ptr = vtable.offset(ptr_size * 2, &self)?;
-        self.memory.write_ptr_sized_unsigned(align_ptr, ptr_align, PrimVal::Bytes(align as u128))?;
+        self.memory.write_ptr_sized_unsigned(align_ptr, ptr_align, Scalar::Bytes(align as u128))?;
 
         for (i, method) in methods.iter().enumerate() {
             if let Some((def_id, substs)) = *method {
                 let instance = self.resolve(def_id, substs)?;
                 let fn_ptr = self.memory.create_fn_alloc(instance);
                 let method_ptr = vtable.offset(ptr_size * (3 + i as u64), &self)?;
-                self.memory.write_ptr_sized_unsigned(method_ptr, ptr_align, PrimVal::Ptr(fn_ptr))?;
+                self.memory.write_ptr_sized_unsigned(method_ptr, ptr_align, Scalar::Ptr(fn_ptr))?;
             }
         }
 
@@ -67,8 +67,8 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
         let pointer_align = self.tcx.data_layout.pointer_align;
         match self.read_ptr(vtable, pointer_align, self.tcx.mk_nil_ptr())? {
             // some values don't need to call a drop impl, so the value is null
-            Value::ByVal(PrimVal::Bytes(0)) => Ok(None),
-            Value::ByVal(PrimVal::Ptr(drop_fn)) => self.memory.get_fn(drop_fn).map(Some),
+            Value::ByVal(Scalar::Bytes(0)) => Ok(None),
+            Value::ByVal(Scalar::Ptr(drop_fn)) => self.memory.get_fn(drop_fn).map(Some),
             _ => err!(ReadBytesAsPointer),
         }
     }