primval -> scalar rename

src/librustc/mir/interpret/value.rs

@@ -37,12 +37,12 @@ pub fn to_byval_value(&self) -> Option<Value> {
     }
 
     #[inline]
-    pub fn from_primval(val: Scalar) -> Self {
+    pub fn from_scalar(val: Scalar) -> Self {
         ConstValue::Scalar(val)
     }
 
     #[inline]
-    pub fn to_primval(&self) -> Option<Scalar> {
+    pub fn to_scalar(&self) -> Option<Scalar> {
         match *self {
             ConstValue::ByRef(..) => None,
             ConstValue::ScalarPair(..) => None,
@@ -52,12 +52,12 @@ pub fn to_primval(&self) -> Option<Scalar> {
 
     #[inline]
     pub fn to_bits(&self, size: Size) -> Option<u128> {
-        self.to_primval()?.to_bits(size).ok()
+        self.to_scalar()?.to_bits(size).ok()
     }
 
     #[inline]
     pub fn to_ptr(&self) -> Option<Pointer> {
-        self.to_primval()?.to_ptr().ok()
+        self.to_scalar()?.to_ptr().ok()
     }
 }
 

src/librustc/ty/sty.rs

@@ -1830,12 +1830,12 @@ pub fn from_byval_value(
     }
 
     #[inline]
-    pub fn from_primval(
+    pub fn from_scalar(
         tcx: TyCtxt<'_, '_, 'tcx>,
         val: Scalar,
         ty: Ty<'tcx>,
     ) -> &'tcx Self {
-        Self::from_const_value(tcx, ConstValue::from_primval(val), ty)
+        Self::from_const_value(tcx, ConstValue::from_scalar(val), ty)
     }
 
     #[inline]
@@ -1847,12 +1847,12 @@ pub fn from_bits(
         let defined = ty.scalar_size(tcx).unwrap_or_else(|| {
             panic!("non-scalar type in from_bits: {:?}", ty)
         }).bits() as u8;
-        Self::from_primval(tcx, Scalar::Bits { bits, defined }, ty)
+        Self::from_scalar(tcx, Scalar::Bits { bits, defined }, ty)
     }
 
     #[inline]
     pub fn zero_sized(tcx: TyCtxt<'_, '_, 'tcx>, ty: Ty<'tcx>) -> &'tcx Self {
-        Self::from_primval(tcx, Scalar::undef(), ty)
+        Self::from_scalar(tcx, Scalar::undef(), ty)
     }
 
     #[inline]
@@ -1894,9 +1894,9 @@ pub fn to_byval_value(&self) -> Option<Value> {
     }
 
     #[inline]
-    pub fn to_primval(&self) -> Option<Scalar> {
+    pub fn to_scalar(&self) -> Option<Scalar> {
         match self.val {
-            ConstVal::Value(val) => val.to_primval(),
+            ConstVal::Value(val) => val.to_scalar(),
             _ => None,
         }
     }

src/librustc_codegen_llvm/mir/constant.rs

@@ -28,7 +28,7 @@
 use super::super::callee;
 use super::FunctionCx;
 
-pub fn primval_to_llvm(cx: &CodegenCx,
+pub fn scalar_to_llvm(cx: &CodegenCx,
                        cv: Scalar,
                        layout: &layout::Scalar,
                        llty: Type) -> ValueRef {
@@ -96,7 +96,7 @@ pub fn const_alloc_to_llvm(cx: &CodegenCx, alloc: &Allocation) -> ValueRef {
             layout.endian,
             &alloc.bytes[offset..(offset + pointer_size)],
         ).expect("const_alloc_to_llvm: could not read relocation pointer") as u64;
-        llvals.push(primval_to_llvm(
+        llvals.push(scalar_to_llvm(
             cx,
             Pointer { alloc_id, offset: Size::from_bytes(ptr_offset) }.into(),
             &layout::Scalar {
@@ -199,13 +199,13 @@ pub fn simd_shuffle_indices(
                         c,
                         constant.ty,
                     )?;
-                    if let Some(prim) = field.to_primval() {
+                    if let Some(prim) = field.to_scalar() {
                         let layout = bx.cx.layout_of(field_ty);
                         let scalar = match layout.abi {
                             layout::Abi::Scalar(ref x) => x,
                             _ => bug!("from_const: invalid ByVal layout: {:#?}", layout)
                         };
-                        Ok(primval_to_llvm(
+                        Ok(scalar_to_llvm(
                             bx.cx, prim, scalar,
                             layout.immediate_llvm_type(bx.cx),
                         ))

src/librustc_codegen_llvm/mir/operand.rs

@@ -28,7 +28,7 @@
 use std::ptr;
 
 use super::{FunctionCx, LocalRef};
-use super::constant::{primval_to_llvm, const_alloc_to_llvm};
+use super::constant::{scalar_to_llvm, const_alloc_to_llvm};
 use super::place::PlaceRef;
 
 /// The representation of a Rust value. The enum variant is in fact
@@ -110,7 +110,7 @@ pub fn from_const(bx: &Builder<'a, 'tcx>,
                     layout::Abi::Scalar(ref x) => x,
                     _ => bug!("from_const: invalid ByVal layout: {:#?}", layout)
                 };
-                let llval = primval_to_llvm(
+                let llval = scalar_to_llvm(
                     bx.cx,
                     x,
                     scalar,
@@ -123,13 +123,13 @@ pub fn from_const(bx: &Builder<'a, 'tcx>,
                     layout::Abi::ScalarPair(ref a, ref b) => (a, b),
                     _ => bug!("from_const: invalid ScalarPair layout: {:#?}", layout)
                 };
-                let a_llval = primval_to_llvm(
+                let a_llval = scalar_to_llvm(
                     bx.cx,
                     a,
                     a_scalar,
                     layout.scalar_pair_element_llvm_type(bx.cx, 0),
                 );
-                let b_llval = primval_to_llvm(
+                let b_llval = scalar_to_llvm(
                     bx.cx,
                     b,
                     b_scalar,

src/librustc_mir/interpret/cast.rs

@@ -8,7 +8,7 @@
 use rustc_apfloat::Float;
 
 impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> EvalContext<'a, 'mir, 'tcx, M> {
-    pub(super) fn cast_primval(
+    pub(super) fn cast_scalar(
         &self,
         val: Scalar,
         src_ty: Ty<'tcx>,

src/librustc_mir/interpret/const_eval.rs

@@ -323,7 +323,7 @@ fn call_intrinsic<'a>(
                     bits: elem_align as u128,
                     defined: dest_layout.size.bits() as u8,
                 };
-                ecx.write_primval(dest, align_val, dest_layout.ty)?;
+                ecx.write_scalar(dest, align_val, dest_layout.ty)?;
             }
 
             "size_of" => {
@@ -333,7 +333,7 @@ fn call_intrinsic<'a>(
                     bits: size,
                     defined: dest_layout.size.bits() as u8,
                 };
-                ecx.write_primval(dest, size_val, dest_layout.ty)?;
+                ecx.write_scalar(dest, size_val, dest_layout.ty)?;
             }
 
             "type_id" => {
@@ -343,7 +343,7 @@ fn call_intrinsic<'a>(
                     bits: type_id,
                     defined: dest_layout.size.bits() as u8,
                 };
-                ecx.write_primval(dest, id_val, dest_layout.ty)?;
+                ecx.write_scalar(dest, id_val, dest_layout.ty)?;
             }
 
             name => return Err(ConstEvalError::NeedsRfc(format!("calling intrinsic `{}`", name)).into()),
@@ -488,7 +488,7 @@ pub fn const_variant_index<'a, 'tcx>(
         },
         Value::ByRef(ptr, align) => (ptr, align),
     };
-    let place = Place::from_primval_ptr(ptr, align);
+    let place = Place::from_scalar_ptr(ptr, align);
     ecx.read_discriminant_as_variant_index(place, ty)
 }
 

src/librustc_mir/interpret/eval_context.rs

@@ -546,9 +546,9 @@ pub(super) fn eval_rvalue_into_place(
             }
 
             UnaryOp(un_op, ref operand) => {
-                let val = self.eval_operand_to_primval(operand)?;
+                let val = self.eval_operand_to_scalar(operand)?;
                 let val = self.unary_op(un_op, val, dest_ty)?;
-                self.write_primval(
+                self.write_scalar(
                     dest,
                     val,
                     dest_ty,
@@ -610,7 +610,7 @@ pub(super) fn eval_rvalue_into_place(
                 let ty = self.place_ty(place);
                 let (_, len) = src.elem_ty_and_len(ty, self.tcx.tcx);
                 let defined = self.memory.pointer_size().bits() as u8;
-                self.write_primval(
+                self.write_scalar(
                     dest,
                     Scalar::Bits {
                         bits: len as u128,
@@ -652,7 +652,7 @@ pub(super) fn eval_rvalue_into_place(
                 assert!(!layout.is_unsized(),
                         "SizeOf nullary MIR operator called for unsized type");
                 let defined = self.memory.pointer_size().bits() as u8;
-                self.write_primval(
+                self.write_scalar(
                     dest,
                     Scalar::Bits {
                         bits: layout.size.bytes() as u128,
@@ -709,7 +709,7 @@ pub(super) fn eval_rvalue_into_place(
                                                     .scalar_size(self.tcx.tcx)
                                                     .expect("can only cast variants to ints")
                                                     .bits() as u8;
-                                        return self.write_primval(
+                                        return self.write_scalar(
                                             dest,
                                             Scalar::Bits {
                                                 bits: discr_val,
@@ -722,8 +722,8 @@ pub(super) fn eval_rvalue_into_place(
                                 layout::Variants::NicheFilling { .. } => {},
                             }
 
-                            let src_val = self.value_to_primval(src)?;
-                            let dest_val = self.cast_primval(src_val, src.ty, dest_ty)?;
+                            let src_val = self.value_to_scalar(src)?;
+                            let dest_val = self.cast_scalar(src_val, src.ty, dest_ty)?;
                             let valty = ValTy {
                                 value: Value::Scalar(dest_val),
                                 ty: dest_ty,
@@ -799,7 +799,7 @@ pub(super) fn eval_rvalue_into_place(
                 let place = self.eval_place(place)?;
                 let discr_val = self.read_discriminant_value(place, ty)?;
                 let defined = ty.scalar_size(self.tcx.tcx).expect("discriminant must be scalar").bits() as u8;
-                self.write_primval(dest, Scalar::Bits {
+                self.write_scalar(dest, Scalar::Bits {
                     bits: discr_val,
                     defined,
                 }, dest_ty)?;
@@ -820,12 +820,12 @@ pub(super) fn type_is_fat_ptr(&self, ty: Ty<'tcx>) -> bool {
         }
     }
 
-    pub(super) fn eval_operand_to_primval(
+    pub(super) fn eval_operand_to_scalar(
         &mut self,
         op: &mir::Operand<'tcx>,
     ) -> EvalResult<'tcx, Scalar> {
         let valty = self.eval_operand(op)?;
-        self.value_to_primval(valty)
+        self.value_to_scalar(valty)
     }
 
     pub(crate) fn operands_to_args(
@@ -923,7 +923,7 @@ pub fn read_discriminant_value(
 
         let (discr_place, discr) = self.place_field(place, mir::Field::new(0), layout)?;
         trace!("discr place: {:?}, {:?}", discr_place, discr);
-        let raw_discr = self.value_to_primval(ValTy {
+        let raw_discr = self.value_to_scalar(ValTy {
             value: self.read_place(discr_place)?,
             ty: discr.ty
         })?;
@@ -1014,7 +1014,7 @@ pub fn write_discriminant_value(
                 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, Scalar::Bits {
+                self.write_scalar(discr_dest, Scalar::Bits {
                     bits: discr_val,
                     defined: size as u8,
                 }, tag.ty)?;
@@ -1030,7 +1030,7 @@ pub fn write_discriminant_value(
                         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, Scalar::Bits {
+                    self.write_scalar(niche_dest, Scalar::Bits {
                         bits: niche_value,
                         defined: niche.size.bits() as u8,
                     }, niche.ty)?;
@@ -1116,20 +1116,20 @@ pub fn follow_by_ref_value(
         }
     }
 
-    pub fn value_to_primval(
+    pub fn value_to_scalar(
         &self,
         ValTy { value, ty } : ValTy<'tcx>,
     ) -> EvalResult<'tcx, Scalar> {
         match self.follow_by_ref_value(value, ty)? {
             Value::ByRef { .. } => bug!("follow_by_ref_value can't result in `ByRef`"),
 
-            Value::Scalar(primval) => {
+            Value::Scalar(scalar) => {
                 // TODO: Do we really want insta-UB here?
-                self.ensure_valid_value(primval, ty)?;
-                Ok(primval)
+                self.ensure_valid_value(scalar, ty)?;
+                Ok(scalar)
             }
 
-            Value::ScalarPair(..) => bug!("value_to_primval can't work with fat pointers"),
+            Value::ScalarPair(..) => bug!("value_to_scalar can't work with fat pointers"),
         }
     }
 
@@ -1141,7 +1141,7 @@ pub fn write_ptr(&mut self, dest: Place, val: Scalar, dest_ty: Ty<'tcx>) -> Eval
         self.write_value(valty, dest)
     }
 
-    pub fn write_primval(
+    pub fn write_scalar(
         &mut self,
         dest: Place,
         val: Scalar,
@@ -1240,18 +1240,18 @@ pub fn write_value_to_ptr(
             Value::ByRef(ptr, align) => {
                 self.memory.copy(ptr, align.min(layout.align), dest, dest_align.min(layout.align), layout.size, false)
             }
-            Value::Scalar(primval) => {
+            Value::Scalar(scalar) => {
                 let signed = match layout.abi {
                     layout::Abi::Scalar(ref scal) => match scal.value {
                         layout::Primitive::Int(_, signed) => signed,
                         _ => false,
                     },
-                    _ => match primval {
+                    _ => match scalar {
                         Scalar::Bits { defined: 0, .. } => false,
                         _ => bug!("write_value_to_ptr: invalid ByVal layout: {:#?}", layout),
                     }
                 };
-                self.memory.write_primval(dest, dest_align, primval, layout.size, signed)
+                self.memory.write_scalar(dest, dest_align, scalar, layout.size, signed)
             }
             Value::ScalarPair(a_val, b_val) => {
                 trace!("write_value_to_ptr valpair: {:#?}", layout);
@@ -1264,13 +1264,13 @@ pub fn write_value_to_ptr(
                 let b_offset = a_size.abi_align(b.align(&self));
                 let b_ptr = dest.ptr_offset(b_offset, &self)?.into();
                 // TODO: What about signedess?
-                self.memory.write_primval(a_ptr, dest_align, a_val, a_size, false)?;
-                self.memory.write_primval(b_ptr, dest_align, b_val, b_size, false)
+                self.memory.write_scalar(a_ptr, dest_align, a_val, a_size, false)?;
+                self.memory.write_scalar(b_ptr, dest_align, b_val, b_size, false)
             }
         }
     }
 
-    pub fn ty_to_primval_kind(&self, ty: Ty<'tcx>) -> EvalResult<'tcx, ScalarKind> {
+    pub fn ty_to_scalar_kind(&self, ty: Ty<'tcx>) -> EvalResult<'tcx, ScalarKind> {
         use syntax::ast::FloatTy;
 
         let kind = match ty.sty {
@@ -1382,7 +1382,7 @@ pub(crate) fn read_ptr(
                         .to_bits(ptr_size)?;
                     Ok(p.to_value_with_len(len as u64, self.tcx.tcx))
                 },
-                _ => bug!("unsized primval ptr read from {:?}", pointee_ty),
+                _ => bug!("unsized scalar ptr read from {:?}", pointee_ty),
             }
         }
     }
@@ -1395,10 +1395,10 @@ pub fn validate_ptr_target(
     ) -> EvalResult<'tcx> {
         match ty.sty {
             ty::TyBool => {
-                self.memory.read_primval(ptr, ptr_align, Size::from_bytes(1))?.to_bool()?;
+                self.memory.read_scalar(ptr, ptr_align, Size::from_bytes(1))?.to_bool()?;
             }
             ty::TyChar => {
-                let c = self.memory.read_primval(ptr, ptr_align, Size::from_bytes(4))?.to_bits(Size::from_bytes(4))? as u32;
+                let c = self.memory.read_scalar(ptr, ptr_align, Size::from_bytes(4))?.to_bits(Size::from_bytes(4))? as u32;
                 match ::std::char::from_u32(c) {
                     Some(..) => (),
                     None => return err!(InvalidChar(c as u128)),
@@ -1421,7 +1421,7 @@ pub fn validate_ptr_target(
 
                 if let layout::Abi::Scalar(ref scalar) = self.layout_of(ty)?.abi {
                     let size = scalar.value.size(self);
-                    self.memory.read_primval(ptr, ptr_align, size)?;
+                    self.memory.read_scalar(ptr, ptr_align, size)?;
                 }
             }
 
@@ -1455,8 +1455,8 @@ pub fn try_read_value(&self, ptr: Scalar, ptr_align: Align, ty: Ty<'tcx>) -> Eva
 
         match layout.abi {
             layout::Abi::Scalar(..) => {
-                let primval = self.memory.read_primval(ptr, ptr_align, layout.size)?;
-                Ok(Some(Value::Scalar(primval)))
+                let scalar = self.memory.read_scalar(ptr, ptr_align, layout.size)?;
+                Ok(Some(Value::Scalar(scalar)))
             }
             layout::Abi::ScalarPair(ref a, ref b) => {
                 let (a, b) = (&a.value, &b.value);
@@ -1464,8 +1464,8 @@ pub fn try_read_value(&self, ptr: Scalar, ptr_align: Align, ty: Ty<'tcx>) -> Eva
                 let a_ptr = ptr;
                 let b_offset = a_size.abi_align(b.align(self));
                 let b_ptr = ptr.offset(b_offset, self)?.into();
-                let a_val = self.memory.read_primval(a_ptr, ptr_align, a_size)?;
-                let b_val = self.memory.read_primval(b_ptr, ptr_align, b_size)?;
+                let a_val = self.memory.read_scalar(a_ptr, ptr_align, a_size)?;
+                let b_val = self.memory.read_scalar(b_ptr, ptr_align, b_size)?;
                 Ok(Some(Value::ScalarPair(a_val, b_val)))
             }
             _ => Ok(None),
@@ -1584,7 +1584,7 @@ fn unsize_into(
                     }
                     let (src_f_value, src_field) = match src {
                         Value::ByRef(ptr, align) => {
-                            let src_place = Place::from_primval_ptr(ptr, align);
+                            let src_place = Place::from_scalar_ptr(ptr, align);
                             let (src_f_place, src_field) =
                                 self.place_field(src_place, mir::Field::new(i), src_layout)?;
                             (self.read_place(src_f_place)?, src_field)

src/librustc_mir/interpret/memory.rs

@@ -707,7 +707,7 @@ pub fn write_repeat(&mut self, ptr: Scalar, val: u8, count: Size) -> EvalResult<
         Ok(())
     }
 
-    pub fn read_primval(&self, ptr: Pointer, ptr_align: Align, size: Size) -> EvalResult<'tcx, Scalar> {
+    pub fn read_scalar(&self, ptr: Pointer, 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)))?;
@@ -738,10 +738,10 @@ pub fn read_primval(&self, ptr: Pointer, ptr_align: Align, size: Size) -> EvalRe
     }
 
     pub fn read_ptr_sized(&self, ptr: Pointer, ptr_align: Align) -> EvalResult<'tcx, Scalar> {
-        self.read_primval(ptr, ptr_align, self.pointer_size())
+        self.read_scalar(ptr, ptr_align, self.pointer_size())
     }
 
-    pub fn write_primval(&mut self, ptr: Scalar, ptr_align: Align, val: Scalar, size: Size, signed: bool) -> EvalResult<'tcx> {
+    pub fn write_scalar(&mut self, ptr: Scalar, ptr_align: Align, val: Scalar, size: Size, signed: bool) -> EvalResult<'tcx> {
         let endianness = self.endianness();
 
         let bytes = match val {
@@ -787,7 +787,7 @@ pub fn write_primval(&mut self, ptr: Scalar, ptr_align: Align, val: Scalar, size
 
     pub fn write_ptr_sized_unsigned(&mut self, ptr: Pointer, ptr_align: Align, val: Scalar) -> EvalResult<'tcx> {
         let ptr_size = self.pointer_size();
-        self.write_primval(ptr.into(), ptr_align, val, ptr_size, false)
+        self.write_scalar(ptr.into(), ptr_align, val, ptr_size, false)
     }
 
     fn int_align(&self, size: Size) -> Align {

src/librustc_mir/interpret/operator.rs

@@ -16,8 +16,8 @@ fn binop_with_overflow(
         left: ValTy<'tcx>,
         right: ValTy<'tcx>,
     ) -> EvalResult<'tcx, (Scalar, bool)> {
-        let left_val = self.value_to_primval(left)?;
-        let right_val = self.value_to_primval(right)?;
+        let left_val = self.value_to_scalar(left)?;
+        let right_val = self.value_to_scalar(right)?;
         self.binary_op(op, left_val, left.ty, right_val, right.ty)
     }
 
@@ -51,7 +51,7 @@ pub fn intrinsic_overflowing(
         dest_ty: Ty<'tcx>,
     ) -> EvalResult<'tcx, bool> {
         let (val, overflowed) = self.binop_with_overflow(op, left, right)?;
-        self.write_primval(dest, val, dest_ty)?;
+        self.write_scalar(dest, val, dest_ty)?;
         Ok(overflowed)
     }
 }
@@ -68,8 +68,8 @@ pub fn binary_op(
     ) -> EvalResult<'tcx, (Scalar, bool)> {
         use rustc::mir::BinOp::*;
 
-        let left_kind = self.ty_to_primval_kind(left_ty)?;
-        let right_kind = self.ty_to_primval_kind(right_ty)?;
+        let left_kind = self.ty_to_scalar_kind(left_ty)?;
+        let right_kind = self.ty_to_scalar_kind(right_ty)?;
         trace!("Running binary op {:?}: {:?} ({:?}), {:?} ({:?})", bin_op, left, left_kind, right, right_kind);
 
         // I: Handle operations that support pointers

src/librustc_mir/interpret/place.rs

@@ -35,10 +35,10 @@ 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(Scalar::undef().into(), Align::from_bytes(1, 1).unwrap())
+        Self::from_scalar_ptr(Scalar::undef().into(), Align::from_bytes(1, 1).unwrap())
     }
 
-    pub fn from_primval_ptr(ptr: Scalar, align: Align) -> Self {
+    pub fn from_scalar_ptr(ptr: Scalar, align: Align) -> Self {
         Place::Ptr {
             ptr,
             align,
@@ -47,7 +47,7 @@ pub fn from_primval_ptr(ptr: Scalar, align: Align) -> Self {
     }
 
     pub fn from_ptr(ptr: Pointer, align: Align) -> Self {
-        Self::from_primval_ptr(ptr.into(), align)
+        Self::from_scalar_ptr(ptr.into(), align)
     }
 
     pub fn to_ptr_align_extra(self) -> (Scalar, Align, PlaceExtra) {
@@ -310,7 +310,7 @@ pub fn val_to_place(&self, val: Value, ty: Ty<'tcx>) -> EvalResult<'tcx, Place>
                     extra: PlaceExtra::Length(len),
                 }
             }
-            _ => Place::from_primval_ptr(self.into_ptr(val)?, layout.align),
+            _ => Place::from_scalar_ptr(self.into_ptr(val)?, layout.align),
         })
     }
 
@@ -388,7 +388,7 @@ pub fn eval_place_projection(
                 let value = self.frame().get_local(local)?;
                 let ty = self.tcx.types.usize;
                 let n = self
-                    .value_to_primval(ValTy { value, ty })?
+                    .value_to_scalar(ValTy { value, ty })?
                     .to_bits(self.tcx.data_layout.pointer_size)?;
                 self.place_index(base, base_ty, n as u64)
             }

src/librustc_mir/interpret/terminator/mod.rs

@@ -38,7 +38,7 @@ pub(super) fn eval_terminator(
                 ..
             } => {
                 let discr_val = self.eval_operand(discr)?;
-                let discr_prim = self.value_to_primval(discr_val)?;
+                let discr_prim = self.value_to_scalar(discr_val)?;
 
                 // Branch to the `otherwise` case by default, if no match is found.
                 let mut target_block = targets[targets.len() - 1];
@@ -67,7 +67,7 @@ pub(super) fn eval_terminator(
                 let func = self.eval_operand(func)?;
                 let (fn_def, sig) = match func.ty.sty {
                     ty::TyFnPtr(sig) => {
-                        let fn_ptr = self.value_to_primval(func)?.to_ptr()?;
+                        let fn_ptr = self.value_to_scalar(func)?.to_ptr()?;
                         let instance = self.memory.get_fn(fn_ptr)?;
                         let instance_ty = instance.ty(*self.tcx);
                         match instance_ty.sty {
@@ -144,17 +144,17 @@ pub(super) fn eval_terminator(
                 target,
                 ..
             } => {
-                let cond_val = self.eval_operand_to_primval(cond)?.to_bool()?;
+                let cond_val = self.eval_operand_to_scalar(cond)?.to_bool()?;
                 if expected == cond_val {
                     self.goto_block(target);
                 } else {
                     use rustc::mir::interpret::EvalErrorKind::*;
                     return match *msg {
                         BoundsCheck { ref len, ref index } => {
-                            let len = self.eval_operand_to_primval(len)
+                            let len = self.eval_operand_to_scalar(len)
                                 .expect("can't eval len")
                                 .to_bits(self.memory().pointer_size())? as u64;
-                            let index = self.eval_operand_to_primval(index)
+                            let index = self.eval_operand_to_scalar(index)
                                 .expect("can't eval index")
                                 .to_bits(self.memory().pointer_size())? as u64;
                             err!(BoundsCheck { len, index })

src/librustc_mir/transform/const_prop.rs

@@ -305,7 +305,7 @@ fn const_prop(
 
                 let val = self.eval_operand(arg)?;
                 let prim = self.use_ecx(span, |this| {
-                    this.ecx.value_to_primval(ValTy { value: val.0, ty: val.1 })
+                    this.ecx.value_to_scalar(ValTy { value: val.0, ty: val.1 })
                 })?;
                 let val = self.use_ecx(span, |this| this.ecx.unary_op(op, prim, val.1))?;
                 Some((Value::Scalar(val), place_ty, span))
@@ -326,7 +326,7 @@ fn const_prop(
                 }
 
                 let r = self.use_ecx(span, |this| {
-                    this.ecx.value_to_primval(ValTy { value: right.0, ty: right.1 })
+                    this.ecx.value_to_scalar(ValTy { value: right.0, ty: right.1 })
                 })?;
                 if op == BinOp::Shr || op == BinOp::Shl {
                     let left_ty = left.ty(self.mir, self.tcx);
@@ -353,7 +353,7 @@ fn const_prop(
                 }
                 let left = self.eval_operand(left)?;
                 let l = self.use_ecx(span, |this| {
-                    this.ecx.value_to_primval(ValTy { value: left.0, ty: left.1 })
+                    this.ecx.value_to_scalar(ValTy { value: left.0, ty: left.1 })
                 })?;
                 trace!("const evaluating {:?} for {:?} and {:?}", op, left, right);
                 let (val, overflow) = self.use_ecx(span, |this| {