Merge branch '⬆️-nightly-2022-03-21' into 🦆

Author: yvt

doc/toolchain_limitations.md

@@ -376,21 +376,6 @@ const fn f(_: usize) {}
 ```
 
 
-### `[tag:const_slice_get]` `<[T]>::get` is not `const fn`
-
-```rust
-assert!(matches!(b"a".get(0), Some(b'a')));
-assert!(matches!(b"a".get(1), None));
-```
-
-```rust,compile_fail,E0015
-// `assert!` is used here due to [ref:const_assert_eq]
-// `matches!` is used here due to [ref:option_const_partial_eq]
-const _: () = assert!(matches!(b"a".get(0), Some(b'a')));
-const _: () = assert!(matches!(b"a".get(1), None));
-```
-
-
 ### `[tag:const_slice_sort_unstable]` `<[T]>::sort_unstable*` is not `const fn`
 
 ```rust
@@ -442,20 +427,6 @@ const _: () = { Ok::<(), ()>(()).map(identity); };
 ```
 
 
-### `[tag:const_slice_get_unchecked]` `<[T]>::get_unchecked` is not `const fn`
-
-```rust
-assert!(unsafe { *b"a".get_unchecked(0) } == b'a');
-```
-
-```rust,compile_fail,E0015
-// `assert!` is used here due to [ref:const_assert_eq]
-// error[E0015]: cannot call non-const fn `core::slice::<impl [u8]>::
-// get_unchecked::<usize>` in constants
-const _: () = assert!(unsafe { *b"a".get_unchecked(0) } == b'a');
-```
-
-
 ### `[tag:const_slice_iter]` `<[T]>::iter` is not `const fn`
 
 ```rust
@@ -661,30 +632,6 @@ const _: () = assert!(matches!((2..4).next(), Some(2)));
 ```
 
 
-### `[tag:clone_from_default]` `Clone::clone_from` lacks `#[default_method_body_is_const]`
-
-When implementing `const Clone`, you can't use the provided implementation of `Clone::clone_from`.
-
-```rust
-#![feature(const_trait_impl)]
-#![feature(const_mut_refs)]
-struct A;
-impl const Clone for A {
-    fn clone(&self) -> Self { A }
-    fn clone_from(&mut self, source: &Self) {}
-}
-```
-
-```rust,compile_fail
-#![feature(const_trait_impl)]
-struct A;
-impl const Clone for A {
-    fn clone(&self) -> Self { A }
-    // error: const trait implementations may not use non-const default functions
-}
-```
-
-
 ### `[tag:iterator_const_default]` `Iterator`'s methods lack `#[default_method_body_is_const]`
 
 Implementing `const Iterator` requires you to implement all of its methods, which is impossible to do correctly.

rust-toolchain

@@ -1 +1 @@
-nightly-2022-03-10
+nightly-2022-03-21

src/r3_core/src/bind.rs

@@ -235,12 +235,6 @@ impl<System, T> const Clone for Bind<'_, System, T> {
     fn clone(&self) -> Self {
         *self
     }
-
-    // `clone_from` needed due to [ref:clone_from_default]
-    #[inline]
-    fn clone_from(&mut self, source: &Self) {
-        *self = *source;
-    }
 }
 
 /// A [binder][1] that gives `&T` to a bound function.
@@ -296,12 +290,6 @@ impl<System, T> const Clone for BindRef<System, T> {
     fn clone(&self) -> Self {
         *self
     }
-
-    // `clone_from` needed due to [ref:clone_from_default]
-    #[inline]
-    fn clone_from(&mut self, source: &Self) {
-        *self = *source;
-    }
 }
 
 // `BindDefiner` doesn't contain `T`, so this `impl` must use a concrete `T`

src/r3_core/src/bind/sorter.rs

@@ -378,17 +378,16 @@ pub(super) const fn sort_bindings<Callback, SorterUseInfoList, VertexList>(
                     SuccessorIterState::BindInitToBorrowingUser(bind_i, bind_user_i) => {
                         let cb = self.cb.borrow();
                         let bind_users = cb.bind_users(bind_i);
-                        // `[T]::get` is not `const fn` yet [ref:const_slice_get]
-                        if bind_user_i < bind_users.len() {
+                        if let Some(bind_user) = bind_users.get(bind_user_i) {
                             self.st = SuccessorIterState::BindInitToBorrowingUser(
                                 bind_i,
                                 bind_user_i + 1,
                             );
                             if matches!(
-                                bind_users[bind_user_i].1,
+                                bind_user.1,
                                 BindBorrowType::Borrow | BindBorrowType::BorrowMut
                             ) {
-                                return Some(match bind_users[bind_user_i].0 {
+                                return Some(match bind_user.0 {
                                     BindUsage::Executable => Vertex::Executable,
                                     BindUsage::Bind(user_bind_i) => Vertex::BindInit(user_bind_i),
                                 });
@@ -434,17 +433,16 @@ pub(super) const fn sort_bindings<Callback, SorterUseInfoList, VertexList>(
                     SuccessorIterState::BindDisownToTakingUser(bind_i, bind_user_i) => {
                         let cb = self.cb.borrow();
                         let bind_users = cb.bind_users(bind_i);
-                        // `[T]::get` is not `const fn` yet [ref:const_slice_get]
-                        if bind_user_i < bind_users.len() {
+                        if let Some(bind_user) = bind_users.get(bind_user_i) {
                             self.st =
                                 SuccessorIterState::BindDisownToTakingUser(bind_i, bind_user_i + 1);
                             if matches!(
-                                bind_users[bind_user_i].1,
+                                bind_user.1,
                                 BindBorrowType::Take
                                     | BindBorrowType::TakeRef
                                     | BindBorrowType::TakeMut
                             ) {
-                                return Some(match bind_users[bind_user_i].0 {
+                                return Some(match bind_user.0 {
                                     BindUsage::Executable => Vertex::Executable,
                                     BindUsage::Bind(user_bind_i) => Vertex::BindInit(user_bind_i),
                                 });

src/r3_core/src/kernel/cfg.rs

@@ -212,12 +212,10 @@ impl<'c, C: raw_cfg::CfgBase> Cfg<'c, C> {
         let mut i = 0;
         while i < self.interrupt_lines.len() {
             let interrupt_line = &self.interrupt_lines[i];
-            // `<[T]>::get` is not `const fn` yet [ref:const_slice_get]
-            let start = if interrupt_line.num < C::System::CFG_INTERRUPT_HANDLERS.len() {
-                C::System::CFG_INTERRUPT_HANDLERS[interrupt_line.num]
-            } else {
-                None
-            };
+            let start = C::System::CFG_INTERRUPT_HANDLERS
+                .get(interrupt_line.num)
+                .copied()
+                .flatten();
             self.raw.interrupt_line_define(
                 raw_cfg::InterruptLineDescriptor {
                     phantom: Init::INIT,

src/r3_core/src/lib.rs

@@ -23,6 +23,7 @@
 #![feature(maybe_uninit_slice)]
 #![feature(const_nonnull_new)]
 #![feature(const_result_drop)]
+#![feature(const_slice_index)]
 #![feature(const_option_ext)]
 #![feature(const_ptr_offset)]
 #![feature(const_trait_impl)]

src/r3_core/src/utils/alloc.rs

@@ -193,10 +193,6 @@ impl const Clone for ConstAllocator {
             ref_count: self.ref_count,
         }
     }
-
-    fn clone_from(&mut self, source: &Self) {
-        *self = source.clone();
-    }
 }
 
 impl const Drop for ConstAllocator {

src/r3_core/src/utils/binary_heap/helpers.rs

@@ -20,7 +20,7 @@ impl<'a, T> Hole<'a, T> {
     pub(super) const unsafe fn new(data: &'a mut [T], pos: usize) -> Self {
         debug_assert!(pos < data.len());
         // SAFE: pos should be inside the slice
-        let elt = unsafe { ptr::read(data.get_unchecked2(pos)) };
+        let elt = unsafe { ptr::read(data.get_unchecked(pos)) };
         Hole {
             data,
             elt: ManuallyDrop::new(elt),
@@ -52,7 +52,7 @@ impl<'a, T> Hole<'a, T> {
     pub(super) const unsafe fn get(&self, index: usize) -> &T {
         debug_assert!(index != self.pos);
         debug_assert!(index < self.data.len());
-        unsafe { self.data.get_unchecked2(index) }
+        unsafe { self.data.get_unchecked(index) }
     }
 
     /// Returns a mutable reference to the element at `index`.
@@ -62,7 +62,7 @@ impl<'a, T> Hole<'a, T> {
     pub(super) const unsafe fn get_mut(&mut self, index: usize) -> &mut T {
         debug_assert!(index != self.pos);
         debug_assert!(index < self.data.len());
-        unsafe { self.data.get_unchecked_mut2(index) }
+        unsafe { self.data.get_unchecked_mut(index) }
     }
 
     /// Move hole to new location
@@ -73,8 +73,8 @@ impl<'a, T> Hole<'a, T> {
         debug_assert!(index != self.pos);
         debug_assert!(index < self.data.len());
         unsafe {
-            let index_ptr: *const _ = self.data.get_unchecked2(index);
-            let hole_ptr = self.data.get_unchecked_mut2(self.pos);
+            let index_ptr: *const _ = self.data.get_unchecked(index);
+            let hole_ptr = self.data.get_unchecked_mut(self.pos);
             ptr::copy_nonoverlapping(index_ptr, hole_ptr, 1);
         }
         self.pos = index;
@@ -87,37 +87,7 @@ impl<T> const Drop for Hole<'_, T> {
         // fill the hole again
         unsafe {
             let pos = self.pos;
-            ptr::copy_nonoverlapping(&*self.elt, self.data.get_unchecked_mut2(pos), 1);
+            ptr::copy_nonoverlapping(&*self.elt, self.data.get_unchecked_mut(pos), 1);
         }
     }
 }
-
-// `[T]::get_unchecked<usize>` is not `const fn` yet [ref:const_slice_get_unchecked]
-trait GetUnchecked {
-    type Element;
-    unsafe fn get_unchecked2(&self, i: usize) -> &Self::Element;
-}
-
-impl<Element> const GetUnchecked for [Element] {
-    type Element = Element;
-
-    #[inline]
-    unsafe fn get_unchecked2(&self, i: usize) -> &Self::Element {
-        unsafe { &*self.as_ptr().add(i) }
-    }
-}
-
-// `[T]::get_unchecked_mut<usize>` is not `const fn` yet [ref:const_slice_get_unchecked]
-trait GetUncheckedMut {
-    type Element;
-    unsafe fn get_unchecked_mut2(&mut self, i: usize) -> &mut Self::Element;
-}
-
-impl<Element> const GetUncheckedMut for [Element] {
-    type Element = Element;
-
-    #[inline]
-    unsafe fn get_unchecked_mut2(&mut self, i: usize) -> &mut Self::Element {
-        unsafe { &mut *self.as_mut_ptr().add(i) }
-    }
-}

src/r3_core/src/utils/freeze.rs

@@ -82,11 +82,6 @@ impl<T: Copy> const Clone for Frozen<T> {
         // Don't use `T as Clone` because it could expose interior mutability.
         *self
     }
-
-    #[inline]
-    fn clone_from(&mut self, source: &Self) {
-        *self = *source;
-    }
 }
 
 impl<T: Copy + ~const fmt::Debug> const fmt::Debug for Frozen<T> {

src/r3_core/src/utils/vec.rs

@@ -35,10 +35,6 @@ impl<T: ~const Clone + ~const Drop> const Clone for ComptimeVec<T> {
         }
         self.map(clone_shim)
     }
-
-    fn clone_from(&mut self, source: &Self) {
-        *self = source.clone();
-    }
 }
 
 impl<T> const Drop for ComptimeVec<T>