Merge branch '⬆️-nightly-2022-06-26' into 🦆

Author: yvt

doc/toolchain_limitations.md

@@ -513,13 +513,15 @@ const _: () = assert!(matches!((2..4).next(), Some(2)));
 ```
 
 
-### `[tag:iterator_const_default]` `Iterator`'s methods lack `#[default_method_body_is_const]`
+### `[tag:iterator_const_default]` `Iterator` lack `#[const_trait]`
 
 Implementing `const Iterator` requires you to implement all of its methods, which is impossible to do correctly.
 
-```rust,compile_fail
+```rust
 #![feature(const_trait_impl)]
 #![feature(const_mut_refs)]
+// FIXME: `compile-fail` temporarily removed due to
+//        [ref:const_impl_of_non_const_trait]
 
 struct MyIterator;
 
@@ -546,6 +548,36 @@ impl const Iterator for MyIterator {
 ```
 
 
+### `[tag:const_impl_of_non_const_trait]` `impl const Trait` doesn't require `#[const_trait]`
+
+A `const` implementation of a non-`#[const_trait]` trait that uses at least one default method implementation doesn't result in a compile error. Instead, an error occurs when the non-`const` default method implementations are actually called in a constant context. This behavior deviates from Rust's design principles, so it's likely a bug.
+
+```rust
+#![feature(const_trait_impl)]
+trait Tr {
+    fn foo() {}
+}
+
+// expected error: const trait implementations may not use non-const default
+// functions / note: `foo` not implemented
+impl const Tr for () {}
+```
+
+```rust
+#![feature(const_trait_impl)]
+#![feature(lint_reasons)]
+trait Tr {
+    fn foo() {}
+}
+
+impl const Tr for () {}
+
+const fn f<T: ~const Tr>() { T::foo() }
+#[expect(const_err)] // error: calling non-const function `<() as Tr>::foo`
+const _: () = f::<()>();
+```
+
+
 ### `[tag:int_const_ord]` `<integer>: !const Ord`
 
 The standard library doesn't provide `const` trait implementations of `Ord` for the built-in integer types.
@@ -627,6 +659,25 @@ const _: () = tokenlock::with_branded_token(|token| {
 ```
 
 
+### `[tag:rust_99793_tait]` False-positive "cycle detected" in `const fn` with TAIT
+
+*Upstream issue:* [rust-lang/rust#99793](https://github.com/rust-lang/rust/issues/99793) (possibly related)
+
+```rust
+#![feature(type_alias_impl_trait)]
+type Unit<T> = impl Copy;
+fn unit<T>(x: T) -> Unit<T> { core::mem::forget(x) }
+```
+
+```rust,compile_fail,E0391
+#![feature(type_alias_impl_trait)]
+type Unit<T> = impl Copy;
+// error[E0391]: cycle detected when computing type of
+// `main::_doctest_main_lib_rs_647_0::Unit::{opaque#0}
+const fn unit<T>(x: T) -> Unit<T> { core::mem::forget(x) }
+```
+
+
 ## Unsized types
 
 ### `[tag:unsized_maybe_uninit]` `MaybeUninit<T>` requires `T: Sized`

rust-toolchain

@@ -1 +1 @@
-nightly-2022-05-20
+nightly-2022-06-26

src/r3_core/src/bag.rs

@@ -2,12 +2,12 @@
 use core::mem::transmute;
 
 /// A heterogeneous collection to store property values.
+#[const_trait]
 pub trait Bag: private::Sealed + Copy {
     /// Insert an item and return a new `impl Bag`.
     ///
     /// For `const fn`-ness, this method can't have a provided implementation.
     #[inline]
-    #[default_method_body_is_const]
     fn insert<T: 'static>(self, head: T) -> List<T, Self> {
         assert!(self.get::<T>().is_none(), "duplicate entry");
         (head, self)

src/r3_core/src/bind.rs

@@ -1196,10 +1196,7 @@ macro_rules! impl_fn_bind {
             {
                 type Output = Output;
 
-                // This opaque type must be defined outside this trait to
-                // prevent the unintended capturing of `$BinderI`.
-                // [ref:opaque_type_extraneous_capture]
-                type BoundFn = BoundFn<T, Output, $( $RuntimeBinderI, )*>;
+                type BoundFn = BoundFn<T, $( $RuntimeBinderI, )*>;
 
                 fn bind(
                     self,
@@ -1209,42 +1206,50 @@ macro_rules! impl_fn_bind {
                     Binder::register_dependency(&binder, ctx);
 
                     let intermediate = Binder::into_runtime_binder(binder);
-                    bind_inner(self, intermediate)
+                    BoundFn {
+                        func: self,
+                        runtime_binders: intermediate,
+                    }
                 }
             }
 
-            type BoundFn<T, Output, $( $RuntimeBinderI, )*>
-            where
-                $( $RuntimeBinderI: RuntimeBinder, )*
-                T: for<'call> FnOnce($( $RuntimeBinderI::Target<'call>, )*)
-                    -> Output + Copy + Send + 'static,
-             = impl FnOnce() -> Output + Copy + Send + 'static;
-
-            const fn bind_inner<
-                T,
-                Output,
-                $( $RuntimeBinderI, )*
-            >(
+            // This opaque type must be defined outside the above `impl` to
+            // prevent the unintended capturing of `$BinderI`.
+            // [ref:opaque_type_extraneous_capture]
+            // type BoundFn<T, Output, $( $RuntimeBinderI, )*>
+            // where
+            //     $( $RuntimeBinderI: RuntimeBinder, )*
+            //     T: for<'call> FnOnce($( $RuntimeBinderI::Target<'call>, )*)
+            //         -> Output + Copy + Send + 'static,
+            //  = impl FnOnce() -> Output + Copy + Send + 'static;
+
+            // FIXME: This is supposed to be a TAIT like the one above, but
+            // [ref:rust_99793_tait] prevents that
+            #[derive(Copy, Clone)]
+            pub struct BoundFn<T, $( $RuntimeBinderI, )*> {
                 func: T,
-                runtime_binders: ( $( $RuntimeBinderI, )* ),
-            ) -> BoundFn<T, Output, $( $RuntimeBinderI, )*>
+                runtime_binders: ($( $RuntimeBinderI, )*),
+            }
+
+            impl<T, Output, $( $RuntimeBinderI, )*> FnOnce<()> for BoundFn<T, $( $RuntimeBinderI, )*>
             where
                 $( $RuntimeBinderI: RuntimeBinder, )*
-                T: for<'call> FnOnce($( $RuntimeBinderI::Target<'call>, )*)
-                    -> Output + Copy + Send + 'static,
+                T: for<'call> FnOnce($( $RuntimeBinderI::Target<'call>, )*) -> Output,
             {
+                type Output = Output;
+
                 #[inline]
-                move || {
+                extern "rust-call" fn call_once(self, (): ()) -> Output {
                     // Safety: `runtime_binders` was created by the corresponding
                     // type's `into_runtime_binder` method.
                     // `CfgBindRegistry::finalize` checks that the borrowing
                     // rules regarding the materialization output are observed.
                     // If the check fails, so does the compilation, and this
                     // runtime code will never be executed.
                     let ($( $fieldI, )*) = unsafe {
-                        <( $( $RuntimeBinderI, )* ) as RuntimeBinder>::materialize(runtime_binders)
+                        <( $( $RuntimeBinderI, )* ) as RuntimeBinder>::materialize(self.runtime_binders)
                     };
-                    func($( $fieldI, )*)
+                    (self.func)($( $fieldI, )*)
                 }
             }
         }; // const _

src/r3_core/src/lib.rs

@@ -19,7 +19,6 @@
 #![feature(const_cell_into_inner)]
 #![feature(const_ptr_offset_from)]
 #![feature(type_alias_impl_trait)]
-#![feature(const_intrinsic_copy)]
 #![feature(const_slice_ptr_len)]
 #![feature(exhaustive_patterns)] // `let Ok(()) = Ok::<(), !>(())`
 #![feature(generic_const_exprs)]
@@ -28,6 +27,7 @@
 #![feature(const_nonnull_new)]
 #![feature(const_result_drop)]
 #![feature(const_slice_index)]
+#![feature(unboxed_closures)] // `impl FnOnce`
 #![feature(const_option_ext)]
 #![feature(const_trait_impl)]
 #![feature(const_ptr_write)]
@@ -49,6 +49,7 @@
 #![feature(decl_macro)]
 #![feature(never_type)] // `!`
 #![feature(const_try)]
+#![feature(fn_traits)] // `impl FnOnce`
 #![feature(let_else)]
 #![feature(doc_cfg)] // `#[doc(cfg(...))]`
 #![cfg_attr(test, feature(is_sorted))]

src/r3_core/src/utils/alloc.rs

@@ -225,13 +225,13 @@ pub struct AllocError;
 /// This trait is subject to [the kernel-side API stability guarantee][1].
 ///
 /// [1]: crate#stability
+#[const_trait]
 pub unsafe trait Allocator {
     /// Attempts to allocate a block of memory.
     fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>;
 
     /// Behaves like `allocate`, but also ensures that the returned memory is
     /// zero-initialized.
-    #[default_method_body_is_const]
     fn allocate_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
         let ptr = const_try_result!(self.allocate(layout));
         // SAFETY: `alloc` returns a valid memory block
@@ -251,7 +251,6 @@ pub unsafe trait Allocator {
     /// # Safety
     ///
     /// See [`core::alloc::Allocator::grow`]'s documentation.
-    #[default_method_body_is_const]
     unsafe fn grow(
         &self,
         ptr: NonNull<u8>,
@@ -284,7 +283,6 @@ pub unsafe trait Allocator {
     /// # Safety
     ///
     /// See [`core::alloc::Allocator::grow_zeroed`]'s documentation.
-    #[default_method_body_is_const]
     unsafe fn grow_zeroed(
         &self,
         ptr: NonNull<u8>,
@@ -316,7 +314,6 @@ pub unsafe trait Allocator {
     /// # Safety
     ///
     /// See [`core::alloc::Allocator::shrink`]'s documentation.
-    #[default_method_body_is_const]
     unsafe fn shrink(
         &self,
         ptr: NonNull<u8>,
@@ -344,7 +341,6 @@ pub unsafe trait Allocator {
     }
 
     /// Creates a “by reference” adapter for this instance of `Allocator`.
-    #[default_method_body_is_const]
     fn by_ref(&self) -> &Self
     where
         Self: Sized,

src/r3_core/src/utils/binary_heap/mod.rs

@@ -11,12 +11,12 @@ mod veclike;
 pub use self::veclike::*;
 
 /// Context type for [`BinaryHeap`]'s operations.
+#[const_trait]
 pub trait BinaryHeapCtx<Element> {
     /// Return `true` iff `x < y`.
     fn lt(&mut self, x: &Element, y: &Element) -> bool;
 
     /// Called when the element `e` is moved to the new position `new_index`.
-    #[default_method_body_is_const]
     fn on_move(&mut self, e: &mut Element, new_index: usize) {
         let _ = (e, new_index);
     }

src/r3_kernel/src/lib.rs

@@ -7,7 +7,6 @@
 #![feature(const_precise_live_drops)]
 #![feature(const_raw_ptr_comparison)]
 #![feature(cfg_target_has_atomic)] // `#[cfg(target_has_atomic_load_store)]`
-#![feature(const_intrinsic_copy)]
 #![feature(exhaustive_patterns)] // `let Ok(()) = Ok::<(), !>(())`
 #![feature(generic_const_exprs)]
 #![feature(const_refs_to_cell)]

src/r3_port_std/src/lib.rs

@@ -22,8 +22,7 @@ use r3_kernel::{KernelTraits, Port, PortToKernel, System, TaskCb, UTicks};
 use spin::Mutex as SpinMutex;
 use std::{
     cell::Cell,
-    lazy::SyncOnceCell,
-    sync::mpsc,
+    sync::{mpsc, OnceLock},
     time::{Duration, Instant},
 };
 
@@ -97,7 +96,7 @@ pub unsafe trait PortInstance:
 /// the corresponding trait methods of `Port*`.
 #[doc(hidden)]
 pub struct State {
-    thread_group: SyncOnceCell<ums::ThreadGroup<sched::SchedState>>,
+    thread_group: OnceLock<ums::ThreadGroup<sched::SchedState>>,
     timer_cmd_send: SpinMutex<Option<mpsc::Sender<TimerCmd>>>,
     origin: AtomicRef<'static, Instant>,
 }
@@ -206,7 +205,7 @@ impl TaskState {
 impl State {
     pub const fn new() -> Self {
         Self {
-            thread_group: SyncOnceCell::new(),
+            thread_group: OnceLock::new(),
             timer_cmd_send: SpinMutex::new(None),
             origin: AtomicRef::new(None),
         }

src/r3_port_std/src/ums.rs

@@ -1,8 +1,8 @@
 //! Utterly inefficient cross-platform preemptive user-mode scheduling
 use slab::Slab;
 use std::{
-    lazy::SyncOnceCell,
     panic::{catch_unwind, AssertUnwindSafe},
+    sync::OnceLock,
     sync::{mpsc, Arc},
     thread::Result,
 };
@@ -75,7 +75,7 @@ struct WorkerThread {
 }
 
 thread_local! {
-    static TLB: SyncOnceCell<ThreadLocalBlock> = SyncOnceCell::new();
+    static TLB: OnceLock<ThreadLocalBlock> = OnceLock::new();
 }
 
 struct ThreadLocalBlock {