don't use drop_in_place as an intrinsic

Author: Gankra

src/doc/nomicon/destructors.md

@@ -26,11 +26,10 @@ this is totally fine.
 For instance, a custom implementation of `Box` might write `Drop` like this:
 
 ```rust
-#![feature(heap_api, core_intrinsics, unique)]
+#![feature(heap_api, drop_in_place, unique)]
 
 use std::rt::heap;
-use std::ptr::Unique;
-use std::intrinsics::drop_in_place;
+use std::ptr::{drop_in_place, Unique};
 use std::mem;
 
 struct Box<T>{ ptr: Unique<T> }
@@ -54,11 +53,10 @@ use-after-free the `ptr` because when drop exits, it becomes inacessible.
 However this wouldn't work:
 
 ```rust
-#![feature(heap_api, core_intrinsics, unique)]
+#![feature(heap_api, drop_in_place, unique)]
 
 use std::rt::heap;
-use std::ptr::Unique;
-use std::intrinsics::drop_in_place;
+use std::ptr::{drop_in_place, Unique};
 use std::mem;
 
 struct Box<T>{ ptr: Unique<T> }
@@ -129,11 +127,10 @@ The classic safe solution to overriding recursive drop and allowing moving out
 of Self during `drop` is to use an Option:
 
 ```rust
-#![feature(heap_api, core_intrinsics, unique)]
+#![feature(heap_api, drop_in_place, unique)]
 
 use std::rt::heap;
-use std::ptr::Unique;
-use std::intrinsics::drop_in_place;
+use std::ptr::{drop_in_place, Unique};
 use std::mem;
 
 struct Box<T>{ ptr: Unique<T> }

src/liballoc/arc.rs

@@ -76,7 +76,7 @@ use core::atomic::Ordering::{Relaxed, Release, Acquire, SeqCst};
 use core::fmt;
 use core::cmp::Ordering;
 use core::mem::{align_of_val, size_of_val};
-use core::intrinsics::{drop_in_place, abort};
+use core::intrinsics::abort;
 use core::mem;
 use core::nonzero::NonZero;
 use core::ops::{Deref, CoerceUnsized};
@@ -265,7 +265,7 @@ impl<T: ?Sized> Arc<T> {
 
         // Destroy the data at this time, even though we may not free the box
         // allocation itself (there may still be weak pointers lying around).
-        drop_in_place(&mut (*ptr).data);
+        ptr::drop_in_place(&mut (*ptr).data);
 
         if self.inner().weak.fetch_sub(1, Release) == 1 {
             atomic::fence(Acquire);

src/liballoc/rc.rs

@@ -159,7 +159,7 @@ use core::cell::Cell;
 use core::cmp::Ordering;
 use core::fmt;
 use core::hash::{Hasher, Hash};
-use core::intrinsics::{assume, drop_in_place, abort};
+use core::intrinsics::{assume, abort};
 use core::marker::{self, Unsize};
 use core::mem::{self, align_of, size_of, align_of_val, size_of_val, forget};
 use core::nonzero::NonZero;
@@ -417,7 +417,7 @@ impl<T: ?Sized> Drop for Rc<T> {
                 self.dec_strong();
                 if self.strong() == 0 {
                     // destroy the contained object
-                    drop_in_place(&mut (*ptr).value);
+                    ptr::drop_in_place(&mut (*ptr).value);
 
                     // remove the implicit "strong weak" pointer now that we've
                     // destroyed the contents.

src/libcollections/lib.rs

@@ -56,6 +56,8 @@
 #![feature(unique)]
 #![feature(unsafe_no_drop_flag, filling_drop)]
 #![feature(utf8_error)]
+#![feature(drop_in_place)]
+
 #![cfg_attr(test, feature(rand, test))]
 
 #![feature(no_std)]

src/libcollections/vec.rs

@@ -65,7 +65,7 @@ use alloc::heap::EMPTY;
 use core::cmp::Ordering;
 use core::fmt;
 use core::hash::{self, Hash};
-use core::intrinsics::{arith_offset, assume, drop_in_place};
+use core::intrinsics::{arith_offset, assume};
 use core::iter::FromIterator;
 use core::mem;
 use core::ops::{Index, IndexMut, Deref};
@@ -1329,7 +1329,7 @@ impl<T> Drop for Vec<T> {
         // don't need unsafe_no_drop_flag shenanigans anymore.
         if self.buf.unsafe_no_drop_flag_needs_drop() {
             for x in self.iter_mut() {
-                unsafe { drop_in_place(x); }
+                unsafe { ptr::drop_in_place(x); }
             }
         }
         // RawVec handles deallocation

src/libstd/lib.rs

@@ -245,6 +245,8 @@
 #![feature(vec_resize)]
 #![feature(wrapping)]
 #![feature(zero_one)]
+#![feature(drop_in_place)]
+
 #![cfg_attr(windows, feature(str_utf16))]
 #![cfg_attr(test, feature(float_from_str_radix, range_inclusive, float_extras, hash_default))]
 #![cfg_attr(test, feature(test, rustc_private, float_consts))]

src/libstd/thread/local.rs

@@ -411,7 +411,7 @@ mod imp {
         if cfg!(target_os = "macos") {
             ptr::read((*ptr).inner.get());
         } else {
-            intrinsics::drop_in_place((*ptr).inner.get());
+            ptr::drop_in_place((*ptr).inner.get());
         }
     }
 }

src/test/run-pass/extern_fat_drop.rs

@@ -10,7 +10,7 @@
 
 // aux-build:fat_drop.rs
 
-#![feature(core_intrinsics)]
+#![feature(core_intrinsics, drop_in_place)]
 
 extern crate fat_drop;