Merge branch 'master' into no-unpin-in-pin-future-impl

Author: jonhoo

Diff for: alloc/Cargo.toml

@@ -11,7 +11,7 @@ edition = "2018"
 
 [dependencies]
 core = { path = "../core" }
-compiler_builtins = { version = "0.1.39", features = ['rustc-dep-of-std'] }
+compiler_builtins = { version = "0.1.40", features = ['rustc-dep-of-std'] }
 
 [dev-dependencies]
 rand = "0.7"

Diff for: alloc/benches/vec.rs

@@ -4,23 +4,13 @@ use test::{black_box, Bencher};
 
 #[bench]
 fn bench_new(b: &mut Bencher) {
-    b.iter(|| {
-        let v: Vec<u32> = Vec::new();
-        assert_eq!(v.len(), 0);
-        assert_eq!(v.capacity(), 0);
-        v
-    })
+    b.iter(|| Vec::<u32>::new())
 }
 
 fn do_bench_with_capacity(b: &mut Bencher, src_len: usize) {
     b.bytes = src_len as u64;
 
-    b.iter(|| {
-        let v: Vec<u32> = Vec::with_capacity(src_len);
-        assert_eq!(v.len(), 0);
-        assert_eq!(v.capacity(), src_len);
-        v
-    })
+    b.iter(|| Vec::<u32>::with_capacity(src_len))
 }
 
 #[bench]
@@ -46,12 +36,7 @@ fn bench_with_capacity_1000(b: &mut Bencher) {
 fn do_bench_from_fn(b: &mut Bencher, src_len: usize) {
     b.bytes = src_len as u64;
 
-    b.iter(|| {
-        let dst = (0..src_len).collect::<Vec<_>>();
-        assert_eq!(dst.len(), src_len);
-        assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
-        dst
-    })
+    b.iter(|| (0..src_len).collect::<Vec<_>>())
 }
 
 #[bench]
@@ -77,12 +62,7 @@ fn bench_from_fn_1000(b: &mut Bencher) {
 fn do_bench_from_elem(b: &mut Bencher, src_len: usize) {
     b.bytes = src_len as u64;
 
-    b.iter(|| {
-        let dst: Vec<usize> = repeat(5).take(src_len).collect();
-        assert_eq!(dst.len(), src_len);
-        assert!(dst.iter().all(|x| *x == 5));
-        dst
-    })
+    b.iter(|| repeat(5).take(src_len).collect::<Vec<usize>>())
 }
 
 #[bench]
@@ -110,12 +90,7 @@ fn do_bench_from_slice(b: &mut Bencher, src_len: usize) {
 
     b.bytes = src_len as u64;
 
-    b.iter(|| {
-        let dst = src.clone()[..].to_vec();
-        assert_eq!(dst.len(), src_len);
-        assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
-        dst
-    });
+    b.iter(|| src.as_slice().to_vec());
 }
 
 #[bench]
@@ -144,9 +119,7 @@ fn do_bench_from_iter(b: &mut Bencher, src_len: usize) {
     b.bytes = src_len as u64;
 
     b.iter(|| {
-        let dst: Vec<_> = FromIterator::from_iter(src.clone());
-        assert_eq!(dst.len(), src_len);
-        assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
+        let dst: Vec<_> = FromIterator::from_iter(src.iter().cloned());
         dst
     });
 }
@@ -180,8 +153,6 @@ fn do_bench_extend(b: &mut Bencher, dst_len: usize, src_len: usize) {
     b.iter(|| {
         let mut dst = dst.clone();
         dst.extend(src.clone());
-        assert_eq!(dst.len(), dst_len + src_len);
-        assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
         dst
     });
 }
@@ -230,8 +201,6 @@ fn do_bench_extend_from_slice(b: &mut Bencher, dst_len: usize, src_len: usize) {
     b.iter(|| {
         let mut dst = dst.clone();
         dst.extend_from_slice(&src);
-        assert_eq!(dst.len(), dst_len + src_len);
-        assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
         dst
     });
 }
@@ -290,12 +259,7 @@ fn do_bench_clone(b: &mut Bencher, src_len: usize) {
 
     b.bytes = src_len as u64;
 
-    b.iter(|| {
-        let dst = src.clone();
-        assert_eq!(dst.len(), src_len);
-        assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
-        dst
-    });
+    b.iter(|| src.clone());
 }
 
 #[bench]
@@ -329,8 +293,7 @@ fn do_bench_clone_from(b: &mut Bencher, times: usize, dst_len: usize, src_len: u
 
         for _ in 0..times {
             dst.clone_from(&src);
-            assert_eq!(dst.len(), src_len);
-            assert!(dst.iter().enumerate().all(|(i, x)| dst_len + i == *x));
+            dst = black_box(dst);
         }
         dst
     });
@@ -463,11 +426,10 @@ macro_rules! bench_in_place {
             fn $fname(b: &mut Bencher) {
                 b.iter(|| {
                     let src: Vec<$type> = black_box(vec![$init; $count]);
-                    let mut sink = src.into_iter()
+                    src.into_iter()
                         .enumerate()
                         .map(|(idx, e)| idx as $type ^ e)
-                        .collect::<Vec<$type>>();
-                    black_box(sink.as_mut_ptr())
+                        .collect::<Vec<$type>>()
                 });
             }
         )+
@@ -506,7 +468,6 @@ fn bench_in_place_recycle(b: &mut Bencher) {
                 .enumerate()
                 .map(|(idx, e)| idx.wrapping_add(e))
                 .fuse()
-                .peekable()
                 .collect::<Vec<usize>>(),
         );
     });
@@ -527,7 +488,6 @@ fn bench_in_place_zip_recycle(b: &mut Bencher) {
             .enumerate()
             .map(|(i, (d, s))| d.wrapping_add(i as u8) ^ s)
             .collect::<Vec<_>>();
-        assert_eq!(mangled.len(), 1000);
         data = black_box(mangled);
     });
 }
@@ -614,23 +574,6 @@ fn bench_nest_chain_chain_collect(b: &mut Bencher) {
     });
 }
 
-pub fn example_plain_slow(l: &[u32]) -> Vec<u32> {
-    let mut result = Vec::with_capacity(l.len());
-    result.extend(l.iter().rev());
-    result
-}
-
-pub fn map_fast(l: &[(u32, u32)]) -> Vec<u32> {
-    let mut result = Vec::with_capacity(l.len());
-    for i in 0..l.len() {
-        unsafe {
-            *result.get_unchecked_mut(i) = l[i].0;
-            result.set_len(i);
-        }
-    }
-    result
-}
-
 #[bench]
 fn bench_range_map_collect(b: &mut Bencher) {
     b.iter(|| (0..LEN).map(|_| u32::default()).collect::<Vec<_>>());
@@ -669,7 +612,11 @@ fn bench_rev_1(b: &mut Bencher) {
 #[bench]
 fn bench_rev_2(b: &mut Bencher) {
     let data = black_box([0; LEN]);
-    b.iter(|| example_plain_slow(&data));
+    b.iter(|| {
+        let mut v = Vec::<u32>::with_capacity(data.len());
+        v.extend(data.iter().rev());
+        v
+    });
 }
 
 #[bench]
@@ -685,7 +632,16 @@ fn bench_map_regular(b: &mut Bencher) {
 #[bench]
 fn bench_map_fast(b: &mut Bencher) {
     let data = black_box([(0, 0); LEN]);
-    b.iter(|| map_fast(&data));
+    b.iter(|| {
+        let mut result = Vec::with_capacity(data.len());
+        for i in 0..data.len() {
+            unsafe {
+                *result.get_unchecked_mut(i) = data[i].0;
+                result.set_len(i);
+            }
+        }
+        result
+    });
 }
 
 fn random_sorted_fill(mut seed: u32, buf: &mut [u32]) {

Diff for: alloc/src/alloc.rs

@@ -308,7 +308,7 @@ unsafe impl Allocator for Global {
 
 /// The allocator for unique pointers.
 // This function must not unwind. If it does, MIR codegen will fail.
-#[cfg(not(test))]
+#[cfg(all(not(no_global_oom_handling), not(test)))]
 #[lang = "exchange_malloc"]
 #[inline]
 unsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 {
@@ -337,6 +337,7 @@ pub(crate) unsafe fn box_free<T: ?Sized, A: Allocator>(ptr: Unique<T>, alloc: A)
 
 // # Allocation error handler
 
+#[cfg(not(no_global_oom_handling))]
 extern "Rust" {
     // This is the magic symbol to call the global alloc error handler.  rustc generates
     // it to call `__rg_oom` if there is a `#[alloc_error_handler]`, or to call the
@@ -358,7 +359,7 @@ extern "Rust" {
 /// [`set_alloc_error_hook`]: ../../std/alloc/fn.set_alloc_error_hook.html
 /// [`take_alloc_error_hook`]: ../../std/alloc/fn.take_alloc_error_hook.html
 #[stable(feature = "global_alloc", since = "1.28.0")]
-#[cfg(not(test))]
+#[cfg(all(not(no_global_oom_handling), not(test)))]
 #[rustc_allocator_nounwind]
 #[cold]
 pub fn handle_alloc_error(layout: Layout) -> ! {
@@ -368,10 +369,10 @@ pub fn handle_alloc_error(layout: Layout) -> ! {
 }
 
 // For alloc test `std::alloc::handle_alloc_error` can be used directly.
-#[cfg(test)]
+#[cfg(all(not(no_global_oom_handling), test))]
 pub use std::alloc::handle_alloc_error;
 
-#[cfg(not(any(target_os = "hermit", test)))]
+#[cfg(all(not(no_global_oom_handling), not(any(target_os = "hermit", test))))]
 #[doc(hidden)]
 #[allow(unused_attributes)]
 #[unstable(feature = "alloc_internals", issue = "none")]

Diff for: alloc/src/borrow.rs

@@ -4,12 +4,15 @@
 
 use core::cmp::Ordering;
 use core::hash::{Hash, Hasher};
-use core::ops::{Add, AddAssign, Deref};
+use core::ops::Deref;
+#[cfg(not(no_global_oom_handling))]
+use core::ops::{Add, AddAssign};
 
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::borrow::{Borrow, BorrowMut};
 
 use crate::fmt;
+#[cfg(not(no_global_oom_handling))]
 use crate::string::String;
 
 use Cow::*;
@@ -429,6 +432,7 @@ impl<T: ?Sized + ToOwned> AsRef<T> for Cow<'_, T> {
     }
 }
 
+#[cfg(not(no_global_oom_handling))]
 #[stable(feature = "cow_add", since = "1.14.0")]
 impl<'a> Add<&'a str> for Cow<'a, str> {
     type Output = Cow<'a, str>;
@@ -440,6 +444,7 @@ impl<'a> Add<&'a str> for Cow<'a, str> {
     }
 }
 
+#[cfg(not(no_global_oom_handling))]
 #[stable(feature = "cow_add", since = "1.14.0")]
 impl<'a> Add<Cow<'a, str>> for Cow<'a, str> {
     type Output = Cow<'a, str>;
@@ -451,6 +456,7 @@ impl<'a> Add<Cow<'a, str>> for Cow<'a, str> {
     }
 }
 
+#[cfg(not(no_global_oom_handling))]
 #[stable(feature = "cow_add", since = "1.14.0")]
 impl<'a> AddAssign<&'a str> for Cow<'a, str> {
     fn add_assign(&mut self, rhs: &'a str) {
@@ -467,6 +473,7 @@ impl<'a> AddAssign<&'a str> for Cow<'a, str> {
     }
 }
 
+#[cfg(not(no_global_oom_handling))]
 #[stable(feature = "cow_add", since = "1.14.0")]
 impl<'a> AddAssign<Cow<'a, str>> for Cow<'a, str> {
     fn add_assign(&mut self, rhs: Cow<'a, str>) {