Leverage Rust 1.79, 1.80 (#9498)

This commit is a follow-up to #9496 to leverage various APIs that the
workspace now has access to. For example most dependencies on the
`once_cell` crate are now removed in favor of the types stabilized in
the standard library: `LazyLock` and `LazyCell`. One dependency remains
in the `wasmtime` crate due to the `get_or_try_init` not being stable
yet.

Some additional helper methods on raw pointer slices are also available
for removing a few minor `unsafe` blocks.

Author: alexcrichton

Cargo.lock

@@ -61,7 +61,6 @@ clap = { workspace = true }
 clap_complete = { workspace = true, optional = true }
 anyhow = { workspace = true, features = ['std'] }
 target-lexicon = { workspace = true }
-once_cell = { workspace = true }
 listenfd = { version = "1.0.0", optional = true }
 wat = { workspace = true, optional = true }
 serde = { workspace = true }
@@ -299,7 +298,6 @@ clap = { version = "4.5.17", default-features = false, features = ["std", "deriv
 clap_complete = "4.4.7"
 hashbrown = { version = "0.14", default-features = false }
 capstone = "0.12.0"
-once_cell = { version = "1.12.0", default-features = false }
 smallvec = { version = "1.6.1", features = ["union"] }
 tracing = "0.1.26"
 bitflags = "2.0"

Cargo.toml

@@ -1,6 +1,6 @@
 use anyhow::Result;
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
-use once_cell::unsync::Lazy;
+use std::cell::LazyCell;
 use std::path::Path;
 use std::process::Command;
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst};
@@ -35,7 +35,7 @@ fn bench_sequential(c: &mut Criterion, path: &Path) {
             benchmark_name(&strategy),
             path.file_name().unwrap().to_str().unwrap(),
         );
-        let state = Lazy::new(|| {
+        let state = LazyCell::new(|| {
             let mut config = Config::default();
             config.allocation_strategy(strategy.clone());
 
@@ -70,7 +70,7 @@ fn bench_parallel(c: &mut Criterion, path: &Path) {
     let mut group = c.benchmark_group("parallel");
 
     for strategy in strategies() {
-        let state = Lazy::new(|| {
+        let state = LazyCell::new(|| {
             let mut config = Config::default();
             config.allocation_strategy(strategy.clone());
 
@@ -153,7 +153,7 @@ fn bench_deserialize_module(c: &mut Criterion, path: &Path) {
 
     let name = path.file_name().unwrap().to_str().unwrap();
     let tmpfile = tempfile::NamedTempFile::new().unwrap();
-    let state = Lazy::new(|| {
+    let state = LazyCell::new(|| {
         let engine = Engine::default();
         let module = Module::from_file(&engine, path).expect("failed to load WASI example module");
         let bytes = module.serialize().unwrap();

benches/instantiation.rs

@@ -17,7 +17,6 @@ workspace = true
 cranelift = { workspace = true }
 cranelift-native = { workspace = true }
 
-anyhow = { workspace = true }
+anyhow = { workspace = true, features = ['std'] }
 arbitrary = { workspace = true }
-once_cell = { workspace = true }
 target-lexicon = { workspace = true, features = ["std"] }

cranelift/fuzzgen/Cargo.toml

@@ -19,10 +19,10 @@ use cranelift::prelude::{
     EntityRef, ExtFuncData, FloatCC, InstBuilder, IntCC, JumpTableData, MemFlags, StackSlotData,
     StackSlotKind,
 };
-use once_cell::sync::Lazy;
 use std::collections::HashMap;
 use std::ops::RangeInclusive;
 use std::str::FromStr;
+use std::sync::LazyLock;
 use target_lexicon::{Architecture, Triple};
 
 type BlockSignature = Vec<Type>;
@@ -789,7 +789,7 @@ fn valid_for_target(triple: &Triple, op: Opcode, args: &[Type], rets: &[Type]) -
 
 type OpcodeSignature = (Opcode, Vec<Type>, Vec<Type>);
 
-static OPCODE_SIGNATURES: Lazy<Vec<OpcodeSignature>> = Lazy::new(|| {
+static OPCODE_SIGNATURES: LazyLock<Vec<OpcodeSignature>> = LazyLock::new(|| {
     let types = &[
         I8, I16, I32, I64, I128, // Scalar Integers
         F32, F64, // Scalar Floats

cranelift/fuzzgen/src/function_generator.rs

@@ -22,7 +22,6 @@ doctest = false
 [dependencies]
 env_logger = { workspace = true, optional = true }
 anyhow = { workspace = true }
-once_cell = { workspace = true }
 wasmtime = { workspace = true, features = ['runtime', 'gc', 'std'] }
 wasmtime-c-api-macros = { workspace = true }
 log = { workspace = true }

crates/c-api/Cargo.toml

@@ -1,6 +1,6 @@
 use crate::{wasm_frame_vec_t, wasm_instance_t, wasm_name_t, wasm_store_t};
 use anyhow::{anyhow, Error};
-use once_cell::unsync::OnceCell;
+use std::cell::OnceCell;
 use wasmtime::{Trap, WasmBacktrace};
 
 #[repr(C)]

crates/c-api/src/trap.rs

@@ -1,5 +1,5 @@
 use crate::{wasm_externtype_t, wasm_name_t, CExternType};
-use once_cell::unsync::OnceCell;
+use std::cell::OnceCell;
 
 #[repr(C)]
 #[derive(Clone)]

crates/c-api/src/types/export.rs

@@ -1,5 +1,5 @@
 use crate::{wasm_externtype_t, wasm_valtype_t, wasm_valtype_vec_t, CExternType};
-use once_cell::unsync::OnceCell;
+use std::cell::OnceCell;
 use std::{
     mem,
     sync::{Arc, Mutex},

crates/c-api/src/types/func.rs

@@ -1,5 +1,5 @@
 use crate::{wasm_externtype_t, wasm_valtype_t, CExternType};
-use once_cell::unsync::OnceCell;
+use std::cell::OnceCell;
 use wasmtime::GlobalType;
 
 pub type wasm_mutability_t = u8;

crates/c-api/src/types/global.rs

@@ -1,5 +1,5 @@
 use crate::{wasm_externtype_t, wasm_name_t, CExternType};
-use once_cell::unsync::OnceCell;
+use std::cell::OnceCell;
 
 #[repr(C)]
 #[derive(Clone)]

crates/c-api/src/types/import.rs

@@ -1,5 +1,5 @@
 use crate::{wasm_externtype_t, wasm_limits_t, CExternType};
-use once_cell::unsync::OnceCell;
+use std::cell::OnceCell;
 use std::convert::TryFrom;
 use wasmtime::MemoryType;
 

crates/c-api/src/types/memory.rs

@@ -1,5 +1,5 @@
 use crate::{wasm_externtype_t, wasm_limits_t, wasm_valtype_t, CExternType};
-use once_cell::unsync::OnceCell;
+use std::cell::OnceCell;
 use wasmtime::{TableType, ValType};
 
 #[repr(transparent)]

crates/c-api/src/types/table.rs

@@ -35,6 +35,5 @@ rustix = { workspace = true, features = ["process"] }
 
 [dev-dependencies]
 filetime = "0.2.7"
-once_cell = { workspace = true }
 pretty_env_logger = { workspace = true }
 tempfile = "3"

crates/cache/Cargo.toml

@@ -1,7 +1,7 @@
-use once_cell::sync::Lazy;
+use std::sync::LazyLock;
 use std::time::{Duration, SystemTime, SystemTimeError};
 
-pub static NOW: Lazy<SystemTime> = Lazy::new(SystemTime::now);
+pub static NOW: LazyLock<SystemTime> = LazyLock::new(SystemTime::now);
 
 #[derive(PartialOrd, PartialEq, Ord, Eq)]
 pub struct SystemTimeStub(SystemTime);

crates/cache/src/worker/tests/system_time_stub.rs

@@ -17,10 +17,9 @@ workspace = true
 # `build-libinterpret` feature set by this crate's parent).
 [dependencies]
 ocaml-interop = { version = "0.8", optional = true }
-once_cell = { workspace = true, optional = true }
 
 [dev-dependencies]
 wat = { workspace = true }
 
 [features]
-build-libinterpret = ["ocaml-interop", "once_cell"]
+build-libinterpret = ["ocaml-interop"]

crates/fuzzing/wasm-spec-interpreter/Cargo.toml

@@ -34,10 +34,9 @@
 
 use crate::{SpecExport, SpecInstance, SpecValue};
 use ocaml_interop::{BoxRoot, OCamlRuntime, ToOCaml};
-use once_cell::sync::Lazy;
 use std::sync::Mutex;
 
-static INTERPRET: Lazy<Mutex<()>> = Lazy::new(|| Mutex::new(()));
+static INTERPRET: Mutex<()> = Mutex::new(());
 
 /// Instantiate the WebAssembly module in the spec interpreter.
 pub fn instantiate(module: &[u8]) -> Result<SpecInstance, String> {

crates/fuzzing/wasm-spec-interpreter/src/with_library.rs

@@ -15,13 +15,12 @@ rust-version.workspace = true
 workspace = true
 
 [dependencies]
-once_cell = { workspace = true, optional = true }
 object = { workspace = true, optional = true }
 wasmtime-versioned-export-macros = { workspace = true }
 
 [target.'cfg(target_os = "linux")'.dependencies]
 rustix = { workspace = true, features = ["mm", "param", "time"], optional = true }
 
 [features]
-gdb_jit_int = ["once_cell"]
+gdb_jit_int = []
 perf_jitdump = ["rustix", "object"]

crates/jit-debug/Cargo.toml

@@ -2,7 +2,6 @@
 //! the __jit_debug_register_code() and __jit_debug_descriptor to register
 //! or unregister generated object images with debuggers.
 
-use once_cell::sync::Lazy;
 use std::pin::Pin;
 use std::ptr;
 use std::sync::Mutex;
@@ -40,7 +39,7 @@ extern "C" {
 ///
 /// The GDB_REGISTRATION lock is needed for GdbJitImageRegistration to protect
 /// access to the __jit_debug_descriptor within this process.
-static GDB_REGISTRATION: Lazy<Mutex<()>> = Lazy::new(|| Mutex::new(Default::default()));
+static GDB_REGISTRATION: Mutex<()> = Mutex::new(());
 
 /// Registration for JIT image
 pub struct GdbJitImageRegistration {

crates/jit-debug/src/gdb_jit_int.rs

@@ -43,7 +43,6 @@ libc = { workspace = true, optional = true }
 rustix = { workspace = true, features = ["fs", "event"] }
 
 [target.'cfg(windows)'.dependencies]
-once_cell = { workspace = true }
 io-extras = { workspace = true }
 rustix = { workspace = true, features = ["net"] }
 

crates/wasi-common/Cargo.toml

@@ -10,9 +10,8 @@
 
 use crate::sched::subscription::{RwEventFlags, Subscription};
 use crate::{file::WasiFile, sched::Poll, Error, ErrorExt};
-use once_cell::sync::Lazy;
 use std::sync::mpsc::{self, Receiver, RecvTimeoutError, Sender, TryRecvError};
-use std::sync::Mutex;
+use std::sync::{LazyLock, Mutex};
 use std::thread;
 use std::time::Duration;
 
@@ -144,7 +143,7 @@ struct StdinPoll {
     notify_rx: Receiver<PollState>,
 }
 
-static STDIN_POLL: Lazy<Mutex<StdinPoll>> = Lazy::new(StdinPoll::new);
+static STDIN_POLL: LazyLock<Mutex<StdinPoll>> = LazyLock::new(StdinPoll::new);
 
 impl StdinPoll {
     pub fn new() -> Mutex<Self> {

crates/wasi-common/src/sync/sched/windows.rs

@@ -35,7 +35,6 @@ async-trait = { workspace = true }
 system-interface = { workspace = true}
 futures = { workspace = true }
 url = { workspace = true }
-once_cell = { workspace = true }
 
 [dev-dependencies]
 tokio = { workspace = true, features = ["time", "sync", "io-std", "io-util", "rt", "rt-multi-thread", "net", "macros", "fs"] }

crates/wasi/Cargo.toml

@@ -21,16 +21,16 @@
 
 use std::future::Future;
 use std::pin::Pin;
+use std::sync::LazyLock;
 use std::task::{Context, Poll};
 
-pub(crate) static RUNTIME: once_cell::sync::Lazy<tokio::runtime::Runtime> =
-    once_cell::sync::Lazy::new(|| {
-        tokio::runtime::Builder::new_multi_thread()
-            .enable_time()
-            .enable_io()
-            .build()
-            .unwrap()
-    });
+pub(crate) static RUNTIME: LazyLock<tokio::runtime::Runtime> = LazyLock::new(|| {
+    tokio::runtime::Builder::new_multi_thread()
+        .enable_time()
+        .enable_io()
+        .build()
+        .unwrap()
+});
 
 /// Exactly like a [`tokio::task::JoinHandle`], except that it aborts the task when
 /// the handle is dropped.

crates/wasi/src/runtime.rs

@@ -46,7 +46,7 @@ sptr = { workspace = true }
 postcard = { workspace = true }
 indexmap = { workspace = true }
 paste = "1.0.3"
-once_cell = { workspace = true }
+once_cell = { version = "1.12.0", optional = true }
 rayon = { version = "1.0", optional = true }
 object = { workspace = true }
 async-trait = { workspace = true, optional = true }
@@ -267,7 +267,7 @@ std = [
   'wasmtime-component-macro?/std',
   'wasmtime-environ/std',
   'object/std',
-  'once_cell/std',
+  'once_cell',
 ]
 
 # Enables support for the `Store::call_hook` API which enables injecting custom

crates/wasmtime/Cargo.toml

@@ -67,7 +67,7 @@ impl Mmap {
 
     #[inline]
     pub fn len(&self) -> usize {
-        unsafe { (*self.memory.as_ptr()).len() }
+        self.memory.as_ptr().len()
     }
 
     pub unsafe fn make_executable(
@@ -102,7 +102,7 @@ impl Drop for Mmap {
     fn drop(&mut self) {
         unsafe {
             let ptr = self.memory.as_ptr().cast();
-            let len = (*self.memory.as_ptr()).len();
+            let len = self.memory.as_ptr().len();
             if len == 0 {
                 return;
             }

crates/wasmtime/src/runtime/vm/sys/custom/mmap.rs

@@ -68,7 +68,7 @@ impl Mmap {
     }
 
     pub fn len(&self) -> usize {
-        unsafe { (*self.memory.as_ptr()).len() }
+        self.memory.as_ptr().len()
     }
 
     pub unsafe fn make_executable(