Reduce reliance on unstable rustc features

.reuse/dep5

@@ -7,6 +7,7 @@ Files:
   Cargo.lock
   support/*.json
   hacking/cargo-manifest-management/tool/Cargo.lock
+  hacking/unstable-feature-monitoring/wishlist/Cargo.lock
   hacking/nix/scope/capdl-tool/capDL-tool.nix
   hacking/nix/scope/capdl-tool/base-compat-0-11-2.nix
   hacking/nix/scope/capdl-tool/base-compat-batteries-0-11-2.nix

crates/examples/microkit/banscii/pds/artist/src/main.rs

@@ -6,8 +6,6 @@
 
 #![no_std]
 #![no_main]
-#![feature(const_trait_impl)]
-#![feature(int_roundings)]
 #![feature(never_type)]
 
 extern crate alloc;

crates/examples/microkit/banscii/pds/assistant/core/test/src/main.rs

@@ -4,8 +4,6 @@
 // SPDX-License-Identifier: BSD-2-Clause
 //
 
-#![feature(int_roundings)]
-
 use banscii_assistant_core::Draft;
 
 fn main() {

crates/examples/microkit/banscii/pds/assistant/src/main.rs

@@ -6,7 +6,6 @@
 
 #![no_std]
 #![no_main]
-#![feature(const_trait_impl)]
 #![feature(never_type)]
 
 extern crate alloc;

crates/examples/microkit/http-server/helpers/virtio-hal-impl/src/lib.rs

@@ -5,10 +5,7 @@
 //
 
 #![no_std]
-#![feature(exposed_provenance)]
-#![feature(ptr_metadata)]
 #![feature(slice_ptr_get)]
-#![feature(strict_provenance)]
 
 use core::alloc::Layout;
 use core::ptr::{self, NonNull};
@@ -43,8 +40,8 @@ pub struct HalImpl;
 
 impl HalImpl {
     pub fn init(dma_region_size: usize, dma_region_vaddr: usize, dma_region_paddr: usize) {
-        let dma_region_ptr = NonNull::new(ptr::from_raw_parts_mut(
-            ptr::from_exposed_addr_mut(dma_region_vaddr),
+        let dma_region_ptr = NonNull::new(ptr::slice_from_raw_parts_mut(
+            dma_region_vaddr as *mut _,
             dma_region_size,
         ))
         .unwrap();

crates/examples/microkit/http-server/pds/server/core/src/lib.rs

@@ -5,7 +5,6 @@
 //
 
 #![no_std]
-#![feature(pattern)]
 
 extern crate alloc;
 
@@ -39,6 +38,7 @@ use server::Server;
 const HTTP_PORT: u16 = 80;
 const HTTPS_PORT: u16 = 443;
 
+#[allow(clippy::too_many_arguments)] // TODO
 pub async fn run_server<
     T: BlockIO<ReadOnly, BlockSize = constant_block_sizes::BlockSize512> + Clone + 'static,
 >(

crates/examples/microkit/http-server/pds/server/core/src/mime.rs

@@ -4,11 +4,9 @@
 // SPDX-License-Identifier: BSD-2-Clause
 //
 
-use core::str::pattern::Pattern;
-
 pub(crate) fn content_type_from_name(name: &str) -> &'static str {
     for (ext, ty) in MIME_ASSOCS {
-        if ext.is_suffix_of(name) {
+        if name.ends_with(ext) {
             return ty;
         }
     }

crates/examples/microkit/http-server/pds/server/core/src/server.rs

@@ -9,7 +9,6 @@ use alloc::format;
 use alloc::rc::Rc;
 use alloc::string::{String, ToString};
 use alloc::vec;
-use core::str::pattern::Pattern;
 
 use sel4_async_block_io_fat as fat;
 use sel4_async_network_traits::{AsyncIO, AsyncIOExt, ClosedError};
@@ -202,10 +201,10 @@ impl<D: fat::BlockDevice + 'static, T: fat::TimeSource + 'static> Server<D, T> {
 
     async fn lookup_request_path(&self, request_path: &str) -> RequestPathStatus {
         let mut volume_manager = self.volume_manager.lock().await;
-        if !"/".is_prefix_of(request_path) {
+        if !request_path.starts_with('/') {
             return RequestPathStatus::NotFound;
         }
-        let has_trailing_slash = "/".is_suffix_of(request_path);
+        let has_trailing_slash = request_path.ends_with('/');
         let mut cur = self.dir;
         for seg in request_path.split('/') {
             if seg.is_empty() {

crates/examples/microkit/http-server/pds/server/src/main.rs

@@ -6,13 +6,7 @@
 
 #![no_std]
 #![no_main]
-#![feature(int_roundings)]
 #![feature(never_type)]
-#![feature(pattern)]
-#![feature(ptr_metadata)]
-#![feature(slice_ptr_get)]
-#![feature(strict_provenance)]
-#![feature(try_blocks)]
 
 extern crate alloc;
 

crates/examples/root-task/example-root-task-without-runtime/src/main.rs

@@ -7,13 +7,11 @@
 #![no_std]
 #![no_main]
 #![feature(core_intrinsics)]
-#![feature(exclusive_wrapper)]
 #![feature(never_type)]
 #![feature(unwrap_infallible)]
 #![allow(internal_features)]
 
 use core::arch::global_asm;
-use core::sync::Exclusive;
 
 fn main(bootinfo: &sel4::BootInfo) -> sel4::Result<!> {
     sel4::debug_println!("Hello, World!");
@@ -81,28 +79,36 @@ fn main(bootinfo: &sel4::BootInfo) -> sel4::Result<!> {
 
 // minimal ad-hoc runtime
 
-#[repr(C, align(16))]
-pub struct Stack<const N: usize>([u8; N]);
+mod stack {
+    use core::cell::UnsafeCell;
 
-impl<const N: usize> Stack<N> {
-    pub const fn new() -> Self {
-        Self([0; N])
-    }
+    #[repr(C, align(16))]
+    pub struct Stack<const N: usize>(UnsafeCell<[u8; N]>);
+
+    unsafe impl<const N: usize> Sync for Stack<N> {}
 
-    pub const fn top(&self) -> StackTop {
-        StackTop(Exclusive::new(self.0.as_ptr_range().end.cast_mut()))
+    impl<const N: usize> Stack<N> {
+        pub const fn new() -> Self {
+            Self(UnsafeCell::new([0; N]))
+        }
+
+        pub const fn top(&self) -> StackTop {
+            StackTop(self.0.get().cast::<u8>().wrapping_add(N))
+        }
     }
-}
 
-#[repr(transparent)]
-pub struct StackTop(#[allow(dead_code)] Exclusive<*mut u8>);
+    #[repr(transparent)]
+    pub struct StackTop(#[allow(dead_code)] *mut u8);
 
-const STACK_SIZE: usize = 0x4000;
+    unsafe impl Sync for StackTop {}
 
-static mut STACK: Stack<STACK_SIZE> = Stack::new();
+    const STACK_SIZE: usize = 0x4000;
 
-#[no_mangle]
-static __stack_top: StackTop = unsafe { STACK.top() };
+    static STACK: Stack<STACK_SIZE> = Stack::new();
+
+    #[no_mangle]
+    static __stack_top: StackTop = STACK.top();
+}
 
 cfg_if::cfg_if! {
     if #[cfg(target_arch = "aarch64")] {

crates/private/support/sel4-simple-task/rpc/src/lib.rs

@@ -5,7 +5,6 @@
 //
 
 #![no_std]
-#![feature(int_roundings)]
 
 #[cfg(feature = "postcard")]
 pub mod easy;

crates/private/support/sel4-simple-task/runtime/config/types/src/lib.rs

@@ -5,8 +5,6 @@
 //
 
 #![no_std]
-#![feature(int_roundings)]
-#![feature(result_flattening)]
 
 #[cfg(feature = "alloc")]
 extern crate alloc;

crates/private/support/sel4-simple-task/runtime/src/lib.rs

@@ -5,17 +5,8 @@
 //
 
 #![no_std]
-#![feature(alloc_error_handler)]
-#![feature(c_size_t)]
-#![feature(const_trait_impl)]
-#![feature(core_intrinsics)]
-#![feature(exposed_provenance)]
-#![feature(lang_items)]
-#![feature(linkage)]
 #![feature(never_type)]
-#![feature(strict_provenance)]
 #![feature(thread_local)]
-#![feature(unwrap_infallible)]
 #![allow(internal_features)]
 
 #[cfg(feature = "alloc")]
@@ -84,9 +75,9 @@ pub unsafe extern "C" fn cont_fn(cont_arg: *mut c_void) -> ! {
 
     THREAD_INDEX.set(thread_index).unwrap();
 
-    sel4::set_ipc_buffer(sel4::IPCBuffer::from_ptr(ptr::from_exposed_addr_mut(
-        thread_config.ipc_buffer_addr().try_into().unwrap(),
-    )));
+    sel4::set_ipc_buffer(sel4::IPCBuffer::from_ptr(
+        usize::try_from(thread_config.ipc_buffer_addr()).unwrap() as *mut _,
+    ));
 
     if thread_index == 0 {
         CONFIG.set(config.clone()).unwrap();
@@ -146,7 +137,7 @@ fn panic_hook(info: &ExternalPanicInfo<'_>) {
 fn get_static_heap_bounds() -> *mut [u8] {
     let addrs = CONFIG.get().unwrap().static_heap().unwrap();
     ptr::slice_from_raw_parts_mut(
-        ptr::from_exposed_addr_mut(addrs.start.try_into().unwrap()),
+        usize::try_from(addrs.start).unwrap() as *mut _,
         (addrs.end - addrs.start).try_into().unwrap(),
     )
 }

crates/private/tests/root-task/loader/src/main.rs

@@ -6,8 +6,6 @@
 
 #![no_std]
 #![no_main]
-#![feature(is_sorted)]
-#![feature(iter_intersperse)]
 #![feature(thread_local)]
 #![allow(clippy::single_match)]
 
@@ -48,8 +46,9 @@ fn main(bootinfo: &sel4::BootInfo) -> ! {
         match extra.id {
             sel4::BootInfoExtraId::Fdt => {
                 let dt = fdt::Fdt::new(extra.content()).unwrap();
-                for s in dt.strings().intersperse(" ") {
-                    debug_print!("{}", s);
+                debug_print!("device tree strings: ");
+                for s in dt.strings() {
+                    debug_print!(" {}", s);
                 }
                 debug_println!("");
             }

crates/sel4-async/block-io/cpiofs/src/lib.rs

@@ -5,9 +5,6 @@
 //
 
 #![no_std]
-#![feature(async_fn_in_trait)]
-#![feature(int_roundings)]
-#![feature(slice_as_chunks)]
 
 extern crate alloc;
 

crates/sel4-async/block-io/src/lib.rs

@@ -6,10 +6,7 @@
 
 #![no_std]
 #![feature(associated_type_bounds)]
-#![feature(const_option)]
-#![feature(int_roundings)]
 #![feature(never_type)]
-#![feature(slice_as_chunks)]
 
 #[cfg(feature = "alloc")]
 extern crate alloc;

crates/sel4-async/single-threaded-executor/src/enter.rs

@@ -37,8 +37,6 @@ impl fmt::Display for EnterError {
     }
 }
 
-impl core::error::Error for EnterError {}
-
 /// Marks the current thread as being within the dynamic extent of an
 /// executor.
 ///

crates/sel4-async/single-threaded-executor/src/lib.rs

@@ -7,16 +7,14 @@
 //
 
 #![no_std]
-#![feature(error_in_core)]
-#![feature(lazy_cell)]
 #![feature(thread_local)]
 
 extern crate alloc;
 
 use alloc::rc::{Rc, Weak};
 use alloc::sync::Arc;
 use alloc::vec::Vec;
-use core::cell::{LazyCell, RefCell};
+use core::cell::{OnceCell, RefCell};
 use core::pin::Pin;
 use core::sync::atomic::{AtomicBool, Ordering};
 
@@ -67,28 +65,29 @@ impl ThreadNotify {
     }
 }
 
-#[thread_local]
-static CURRENT_THREAD_NOTIFY: LazyCell<Arc<ThreadNotify>> =
-    LazyCell::new(|| Arc::new(ThreadNotify::new()));
-
 impl ArcWake for ThreadNotify {
     fn wake_by_ref(arc_self: &Arc<Self>) {
         ThreadNotify::wake(arc_self);
     }
 }
 
 fn run_executor_until_stalled<T, F: FnMut(&mut Context<'_>) -> Poll<T>>(mut f: F) -> Poll<T> {
+    #[thread_local]
+    static CURRENT_THREAD_NOTIFY: OnceCell<Arc<ThreadNotify>> = OnceCell::new();
+
     let _enter =
         enter::enter().expect("cannot execute `LocalPool` executor from within another executor");
 
-    let waker = waker_ref(&CURRENT_THREAD_NOTIFY);
+    let current_thread_notify = CURRENT_THREAD_NOTIFY.get_or_init(|| Arc::new(ThreadNotify::new()));
+
+    let waker = waker_ref(current_thread_notify);
     let mut cx = Context::from_waker(&waker);
     loop {
         if let Poll::Ready(t) = f(&mut cx) {
             return Poll::Ready(t);
         }
 
-        if !CURRENT_THREAD_NOTIFY.take_wakeup() {
+        if !current_thread_notify.take_wakeup() {
             return Poll::Pending;
         }
     }

crates/sel4-bounce-buffer-allocator/src/lib.rs

@@ -8,7 +8,6 @@
 #![feature(allocator_api)]
 #![feature(btree_cursors)]
 #![feature(btreemap_alloc)]
-#![feature(int_roundings)]
 #![feature(pointer_is_aligned)]
 
 extern crate alloc;

crates/sel4-capdl-initializer/add-spec/src/main.rs

@@ -5,7 +5,6 @@
 //
 
 #![feature(associated_type_bounds)]
-#![feature(int_roundings)]
 #![feature(never_type)]
 #![feature(unwrap_infallible)]
 

crates/sel4-capdl-initializer/core/src/hold_slots.rs

@@ -4,8 +4,6 @@
 // SPDX-License-Identifier: BSD-2-Clause
 //
 
-use core::array;
-
 use sel4::{AbsoluteCPtr, InitCSpaceSlot};
 
 use crate::{CSlotAllocator, CapDLInitializerError};
@@ -25,7 +23,11 @@ impl<T> HoldSlots<T> {
         relative_cptr_of: T,
     ) -> Result<Self, CapDLInitializerError> {
         Ok(Self {
-            slots: array::try_from_fn(|_| cslot_allocator.alloc())?,
+            slots: {
+                // NOTE(rustc_wishlist) array_try_from_fn
+                let mut f = || cslot_allocator.alloc();
+                [f()?, f()?]
+            },
             slots_occupied: [false; NUM_SLOTS],
             which_slot: 0,
             relative_cptr_of,