Implement no_std support for Wasm

Author: daxpedda

.github/workflows/tests.yml

@@ -257,15 +257,15 @@ jobs:
       - name: Test (Node)
         env:
           RUSTFLAGS: -Dwarnings --cfg getrandom_backend="wasm_js"
-        run: wasm-pack test --node
+        run: wasm-pack test --node -- --features std
       - name: Test (Firefox)
         env:
           RUSTFLAGS: -Dwarnings --cfg getrandom_backend="wasm_js" --cfg getrandom_browser_test
-        run: wasm-pack test --headless --firefox
+        run: wasm-pack test --headless --firefox -- --features std
       - name: Test (Chrome)
         env:
           RUSTFLAGS: -Dwarnings --cfg getrandom_backend="wasm_js" --cfg getrandom_browser_test
-        run: wasm-pack test --headless --chrome
+        run: wasm-pack test --headless --chrome -- --features std
 
   wasi:
     name: WASI

.github/workflows/workspace.yml

@@ -23,7 +23,7 @@ jobs:
         # Fixed Nigthly version is used to prevent
         # CI failures which are not relevant to PR changes
         # on introduction of new Clippy lints.
-        toolchain: nightly-2024-10-08
+        toolchain: nightly-2024-10-24
         components: clippy,rust-src
     - name: std feature
       run: cargo clippy --features std
@@ -48,7 +48,15 @@ jobs:
     - name: Web WASM (wasm_js.rs)
       env:
         RUSTFLAGS: -Dwarnings --cfg getrandom_backend="wasm_js"
-      run: cargo clippy -Zbuild-std --target wasm32-unknown-unknown
+      run: cargo clippy --features std -Zbuild-std=panic_abort,std --target wasm32-unknown-unknown
+    - name: Web WASM no_std (wasm_js.rs)
+      env:
+        RUSTFLAGS: -Dwarnings --cfg getrandom_backend="wasm_js"
+      run: cargo clippy -Zbuild-std=core,alloc --target wasm32-unknown-unknown
+    - name: Web WASM no_std with atomics (wasm_js.rs)
+      env:
+        RUSTFLAGS: -Dwarnings --cfg getrandom_backend="wasm_js" -Ctarget-feature=+atomics,+bulk-memory
+      run: cargo clippy -Zbuild-std=core,alloc --target wasm32-unknown-unknown
     - name: Linux (linux_android.rs)
       env:
         RUSTFLAGS: -Dwarnings --cfg getrandom_backend="linux_getrandom"

Cargo.toml

@@ -64,15 +64,16 @@ windows-targets = "0.52"
 
 # wasm_js
 [target.'cfg(all(getrandom_backend = "wasm_js", target_arch = "wasm32", target_os = "unknown"))'.dependencies]
-wasm-bindgen = { version = "0.2.89", default-features = false }
-js-sys = "0.3"
+wasm-bindgen = { version = "0.2.96", default-features = false }
+js-sys = { version = "0.3.73", default-features = false }
+once_cell = { version = "1", default-features = false }
 [target.'cfg(all(getrandom_backend = "wasm_js", getrandom_browser_test, target_arch = "wasm32", target_os = "unknown"))'.dev-dependencies]
-wasm-bindgen-test = "0.3.39"
+wasm-bindgen-test = { version = "0.3", default-features = false }
 
 [features]
 # Implement std::error::Error for getrandom::Error and
 # use std to retrieve OS error descriptions
-std = []
+std = ["wasm-bindgen/std", "js-sys/std", "wasm-bindgen-test/std"]
 # Unstable feature to support being a libstd dependency
 rustc-dep-of-std = ["compiler_builtins", "core"]
 

src/backends/wasm_js.rs

@@ -1,15 +1,18 @@
 //! Implementation for WASM based on Web and Node.js
 use crate::Error;
 
+#[cfg(feature = "std")]
 extern crate std;
-use std::{mem::MaybeUninit, thread_local};
+use core::mem::MaybeUninit;
 
 pub use crate::util::{inner_u32, inner_u64};
 
 #[cfg(not(all(target_arch = "wasm32", target_os = "unknown",)))]
 compile_error!("`wasm_js` backend can be enabled only for OS-less WASM targets!");
 
 use js_sys::{global, Function, Uint8Array};
+#[cfg(not(feature = "std"))]
+use once_cell::unsync::Lazy;
 use wasm_bindgen::{prelude::wasm_bindgen, JsCast, JsValue};
 
 // Size of our temporary Uint8Array buffer used with WebCrypto methods
@@ -25,12 +28,37 @@ enum RngSource {
 
 // JsValues are always per-thread, so we initialize RngSource for each thread.
 //   See: https://github.com/rustwasm/wasm-bindgen/pull/955
-thread_local!(
-    static RNG_SOURCE: Result<RngSource, Error> = getrandom_init();
-);
+struct Local;
+
+impl Local {
+    #[cfg(feature = "std")]
+    fn with<R>(f: impl FnOnce(&Result<RngSource, Error>) -> R) -> R {
+        std::thread_local!(
+            static RNG_SOURCE: Result<RngSource, Error> = getrandom_init();
+        );
+        RNG_SOURCE.with(f)
+    }
+
+    #[cfg(all(not(feature = "std"), not(target_feature = "atomics")))]
+    fn with<R>(f: impl FnOnce(&Result<RngSource, Error>) -> R) -> R {
+        struct Wrapper<T>(T);
+        unsafe impl<T> Send for Wrapper<T> {}
+        unsafe impl<T> Sync for Wrapper<T> {}
+        static RNG_SOURCE: Wrapper<Lazy<Result<RngSource, Error>>> =
+            Wrapper(Lazy::new(getrandom_init));
+        f(&RNG_SOURCE.0)
+    }
+
+    #[cfg(all(not(feature = "std"), target_feature = "atomics"))]
+    fn with<R>(f: impl FnOnce(&Result<RngSource, Error>) -> R) -> R {
+        #[thread_local]
+        static RNG_SOURCE: Lazy<Result<RngSource, Error>> = Lazy::new(getrandom_init);
+        f(&RNG_SOURCE)
+    }
+}
 
 pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
-    RNG_SOURCE.with(|result| {
+    Local::with(|result| {
         let source = result.as_ref().map_err(|&e| e)?;
 
         match source {

src/lib.rs

@@ -11,6 +11,16 @@
 #![warn(rust_2018_idioms, unused_lifetimes, missing_docs)]
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
 #![cfg_attr(getrandom_sanitize, feature(cfg_sanitize))]
+#![cfg_attr(
+    all(
+        getrandom_backend = "wasm_js",
+        any(target_arch = "wasm32", target_arch = "wasm64"),
+        target_os = "unknown",
+        not(feature = "std"),
+        target_feature = "atomics"
+    ),
+    feature(thread_local)
+)]
 #![deny(
     clippy::cast_lossless,
     clippy::cast_possible_truncation,