Retire to_ptr which should already have no users but still kept get…

…ting new ones

src/librustc/mir/interpret/value.rs

@@ -367,8 +367,9 @@ impl<'tcx, Tag> Scalar<Tag> {
     }
 
     /// Do not call this method!  Use either `assert_ptr` or `force_ptr`.
+    /// This method is intentionally private, do not make it public.
     #[inline]
-    pub fn to_ptr(self) -> InterpResult<'tcx, Pointer<Tag>> {
+    fn to_ptr(self) -> InterpResult<'tcx, Pointer<Tag>> {
         match self {
             Scalar::Raw { data: 0, .. } => throw_unsup!(InvalidNullPointerUsage),
             Scalar::Raw { .. } => throw_unsup!(ReadBytesAsPointer),
@@ -544,12 +545,6 @@ impl<'tcx, Tag> ScalarMaybeUndef<Tag> {
         }
     }
 
-    /// Do not call this method!  Use either `assert_ptr` or `force_ptr`.
-    #[inline(always)]
-    pub fn to_ptr(self) -> InterpResult<'tcx, Pointer<Tag>> {
-        self.not_undef()?.to_ptr()
-    }
-
     /// Do not call this method!  Use either `assert_bits` or `force_bits`.
     #[inline(always)]
     pub fn to_bits(self, target_size: Size) -> InterpResult<'tcx, u128> {

src/librustc/ty/relate.rs

@@ -537,8 +537,8 @@ pub fn super_relate_consts<R: TypeRelation<'tcx>>(
                         Ok(ConstValue::Scalar(a_val))
                     } else if let ty::FnPtr(_) = a.ty.kind {
                         let alloc_map = tcx.alloc_map.lock();
-                        let a_instance = alloc_map.unwrap_fn(a_val.to_ptr().unwrap().alloc_id);
-                        let b_instance = alloc_map.unwrap_fn(b_val.to_ptr().unwrap().alloc_id);
+                        let a_instance = alloc_map.unwrap_fn(a_val.assert_ptr().alloc_id);
+                        let b_instance = alloc_map.unwrap_fn(b_val.assert_ptr().alloc_id);
                         if a_instance == b_instance {
                             Ok(ConstValue::Scalar(a_val))
                         } else {

src/librustc_mir/const_eval.rs

@@ -85,7 +85,7 @@ fn op_to_const<'tcx>(
     };
     let val = match immediate {
         Ok(mplace) => {
-            let ptr = mplace.ptr.to_ptr().unwrap();
+            let ptr = mplace.ptr.assert_ptr();
             let alloc = ecx.tcx.alloc_map.lock().unwrap_memory(ptr.alloc_id);
             ConstValue::ByRef { alloc, offset: ptr.offset }
         },
@@ -99,7 +99,7 @@ fn op_to_const<'tcx>(
                 // comes from a constant so it can happen have `Undef`, because the indirect
                 // memory that was read had undefined bytes.
                 let mplace = op.assert_mem_place();
-                let ptr = mplace.ptr.to_ptr().unwrap();
+                let ptr = mplace.ptr.assert_ptr();
                 let alloc = ecx.tcx.alloc_map.lock().unwrap_memory(ptr.alloc_id);
                 ConstValue::ByRef { alloc, offset: ptr.offset }
             },
@@ -626,7 +626,7 @@ fn validate_and_turn_into_const<'tcx>(
         // whether they become immediates.
         let def_id = cid.instance.def.def_id();
         if tcx.is_static(def_id) || cid.promoted.is_some() {
-            let ptr = mplace.ptr.to_ptr()?;
+            let ptr = mplace.ptr.assert_ptr();
             Ok(tcx.mk_const(ty::Const {
                 val: ty::ConstKind::Value(ConstValue::ByRef {
                     alloc: ecx.tcx.alloc_map.lock().unwrap_memory(ptr.alloc_id),

src/librustc_mir/interpret/eval_context.rs

@@ -743,7 +743,9 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         // FIXME: should we tell the user that there was a local which was never written to?
         if let LocalValue::Live(Operand::Indirect(MemPlace { ptr, .. })) = local {
             trace!("deallocating local");
-            let ptr = ptr.to_ptr()?;
+            // All locals have a backing allocation, even if the allocation is empty
+            // due to the local having ZST type.
+            let ptr = ptr.assert_ptr();
             if log_enabled!(::log::Level::Trace) {
                 self.memory.dump_alloc(ptr.alloc_id);
             }

src/librustc_mir/interpret/intern.rs

@@ -192,11 +192,12 @@ impl<'rt, 'mir, 'tcx, M: CompileTimeMachine<'mir, 'tcx>> ValueVisitor<'mir, 'tcx
             if let ty::Dynamic(..) =
                 self.ecx.tcx.struct_tail_erasing_lifetimes(referenced_ty, self.ecx.param_env).kind
             {
-                if let Ok(vtable) = mplace.meta.unwrap().to_ptr() {
-                    // explitly choose `Immutable` here, since vtables are immutable, even
-                    // if the reference of the fat pointer is mutable
-                    self.intern_shallow(vtable.alloc_id, Mutability::Not, None)?;
-                }
+                // Validation has already errored on an invalid vtable pointer so this `assert_ptr`
+                // will never panic.
+                let vtable = mplace.meta.unwrap().assert_ptr();
+                // explitly choose `Immutable` here, since vtables are immutable, even
+                // if the reference of the fat pointer is mutable
+                self.intern_shallow(vtable.alloc_id, Mutability::Not, None)?;
             }
             // Check if we have encountered this pointer+layout combination before.
             // Only recurse for allocation-backed pointers.
@@ -281,7 +282,9 @@ pub fn intern_const_alloc_recursive<M: CompileTimeMachine<'mir, 'tcx>>(
         ecx,
         leftover_allocations,
         base_intern_mode,
-        ret.ptr.to_ptr()?.alloc_id,
+        // The outermost allocation must exist, because we allocated it with
+        // `Memory::allocate`.
+        ret.ptr.assert_ptr().alloc_id,
         base_mutability,
         Some(ret.layout.ty),
     )?;