Adopt wasm-bindgen unwind safety enforcement

Update wasm-bindgen submodule to pick up unwind safety enforcement
on #[wasm_bindgen] exports (wasm-bindgen/wasm-bindgen#5128).

Add wasm-streams and gloo as submodules pointing at forks that
propagate unwind safety bounds through closures and timers. Patch
both via [patch.crates-io] so the worker crate compiles against the
new enforcement.

Refactor durable object test fixtures to use Cell wrapped in
AssertUnwindSafe, replacing RefCell. Cell is single-threaded safe
for Copy types because every operation is an atomic move with no
borrow guard to leave dangling; AssertUnwindSafe is the narrow,
honest assertion for the interior mutability fields without making
blanket promises about State/Env.

Add cargo url replacement so transitive git deps fetched via SSH
fall back to HTTPS for cargo generate users.

Author: guybedford

.cargo/config.toml

@@ -1,2 +1,5 @@
 [target.wasm32-unknown-unknown]
 rustflags = ["--cfg", "getrandom_backend=\"wasm_js\""]
+
+[url."https://github.com/"]
+insteadOf = ["git@github.com:", "ssh://git@github.com/"]

.gitmodules

@@ -1,9 +1,14 @@
 [submodule "wasm-bindgen"]
 	path = wasm-bindgen
 	url = https://github.com/wasm-bindgen/wasm-bindgen
-[submodule "wasm-streams"]
-	path = wasm-streams
-	url = https://github.com/guybedford/wasm-streams
 [submodule "ts-gen"]
 	path = ts-gen
 	url = https://github.com/wasm-bindgen/ts-gen
+[submodule "wasm-streams"]
+	path = wasm-streams
+	url = https://github.com/guybedford/wasm-streams
+	branch = fix-unwind-safety-impls
+[submodule "gloo"]
+	path = gloo
+	url = https://github.com/guybedford/gloo
+	branch = fix-gloo-timers-unwind-safety

Cargo.lock

@@ -14,6 +14,8 @@ exclude = [
     "examples/axum",
     "templates/*",
     "wasm-bindgen",
+    "wasm-streams",
+    "gloo",
     "generated",
 ]
 resolver = "2"
@@ -27,7 +29,7 @@ chrono = { version = "0.4.41", default-features = false, features = [
 futures-channel = "0.3.31"
 futures-util = { version = "0.3.31", default-features = false }
 http = "1.3"
-js-sys = { version = "0.3.98" }
+js-sys = { version = "0.3.99" }
 serde = { version = "1.0.164", features = ["derive"] }
 strum = { version = "0.27", features = ["derive"] }
 serde_json = "1.0.140"
@@ -36,14 +38,14 @@ syn = "2.0.17"
 trybuild = "1.0"
 proc-macro2 = "1.0.60"
 quote = "1.0.28"
-wasm-bindgen = { version = "0.2.121" }
-wasm-bindgen-cli-support = { version = "0.2.121" }
-wasm-bindgen-futures = { version = "0.4.71" }
-wasm-bindgen-macro-support = { version = "0.2.121" }
-wasm-bindgen-shared = { version = "0.2.121" }
-wasm-bindgen-test = { version = "0.3.71" }
+wasm-bindgen = { version = "0.2.122" }
+wasm-bindgen-cli-support = { version = "0.2.122" }
+wasm-bindgen-futures = { version = "0.4.72" }
+wasm-bindgen-macro-support = { version = "0.2.122" }
+wasm-bindgen-shared = { version = "0.2.122" }
+wasm-bindgen-test = { version = "0.3.72" }
 wasm-streams = { version = "0.5.0" }
-web-sys = { version = "0.3.98", features = [
+web-sys = { version = "0.3.99", features = [
     "AbortController",
     "AbortSignal",
     "BinaryType",
@@ -105,11 +107,12 @@ opt-level = "z"
 # These are local patches we use to test against local wasm bindgen
 # We always align on the exact stable wasm bindgen version for releases
 [patch.crates-io]
-js-sys = { version = "0.3.98", path = './wasm-bindgen/crates/js-sys' }
-wasm-bindgen = { version = "0.2.121", path = './wasm-bindgen' }
-wasm-bindgen-cli-support = { version = "0.2.121", path = "./wasm-bindgen/crates/cli-support" }
-wasm-bindgen-futures = { version = "0.4.71", path = './wasm-bindgen/crates/futures' }
-wasm-bindgen-macro-support = { version = "0.2.121", path = "./wasm-bindgen/crates/macro-support" }
-wasm-bindgen-shared = { version = "0.2.121", path = "./wasm-bindgen/crates/shared" }
-wasm-bindgen-test = { version = "0.3.71", path = "./wasm-bindgen/crates/test" }
-web-sys = { version = "0.3.98", path = './wasm-bindgen/crates/web-sys' }
+js-sys = { version = "0.3.99", path = './wasm-bindgen/crates/js-sys' }
+wasm-bindgen = { version = "0.2.122", path = './wasm-bindgen' }
+wasm-bindgen-cli-support = { version = "0.2.122", path = "./wasm-bindgen/crates/cli-support" }
+wasm-bindgen-futures = { version = "0.4.72", path = './wasm-bindgen/crates/futures' }
+wasm-bindgen-macro-support = { version = "0.2.122", path = "./wasm-bindgen/crates/macro-support" }
+wasm-bindgen-shared = { version = "0.2.122", path = "./wasm-bindgen/crates/shared" }
+wasm-bindgen-test = { version = "0.3.72", path = "./wasm-bindgen/crates/test" }
+web-sys = { version = "0.3.99", path = './wasm-bindgen/crates/web-sys' }
+wasm-streams = { version = "0.5.0", path = './wasm-streams' }

Cargo.toml

@@ -28,7 +28,7 @@ impl Calculator for CalculatorService {
     async fn add(&self, a: u32, b: u32) -> ::worker::Result<u32> {
         let promise = self.0.add(a, b)?;
         let fut = ::worker::send::SendFuture::new(
-            ::worker::wasm_bindgen_futures::JsFuture::from(promise),
+            ::worker::js_sys::futures::JsFuture::from(promise),
         );
         let output = fut.await?;
         Ok(::serde_wasm_bindgen::from_value(output)?)

examples/rpc-client/src/calculator.rs

@@ -8,7 +8,6 @@ use std::time::Duration;
 
 use futures_util::StreamExt;
 use wasm_bindgen::{throw_str, UnwrapThrowExt};
-use wasm_bindgen_futures::spawn_local;
 use worker::*;
 
 use crate::SomeSharedData;
@@ -29,7 +28,7 @@ impl DurableObject for EchoContainer {
         }
         let ready = Arc::new(AtomicBool::new(false));
         let ready_clone = Arc::clone(&ready);
-        spawn_local(async move {
+        js_sys::futures::spawn_local(async move {
             for _ in 0..10 {
                 match container
                     .get_tcp_port(8080)
@@ -112,7 +111,7 @@ pub async fn handle_container(
                 None => return Response::error("Expected websocket response", 500),
             };
             ws.accept()?;
-            spawn_local(redir_websocket(ws, server));
+            js_sys::futures::spawn_local(redir_websocket(ws, server));
             Response::from_websocket(client)
         }
         _ => Response::error("Container method not allowed", 405),

gloo

@@ -1,37 +1,39 @@
-use std::cell::RefCell;
+use std::cell::Cell;
+use std::panic::AssertUnwindSafe;
 use tokio_stream::{StreamExt, StreamMap};
 use worker::{
-    durable_object, wasm_bindgen, wasm_bindgen_futures, DurableObject, Env, Error, Method, Request,
-    Response, ResponseBuilder, Result, State, WebSocket, WebSocketIncomingMessage, WebSocketPair,
-    WebsocketEvent,
+    durable_object, wasm_bindgen, DurableObject, Env, Error, Method, Request, Response,
+    ResponseBuilder, Result, State, WebSocket, WebSocketIncomingMessage, WebSocketPair,
+    WebsocketEvent, js_sys
 };
 
 use crate::SomeSharedData;
 
 #[durable_object]
 pub struct Counter {
-    count: RefCell<usize>,
-    unstored_count: RefCell<usize>,
+    count: AssertUnwindSafe<Cell<usize>>,
+    unstored_count: AssertUnwindSafe<Cell<usize>>,
     state: State,
-    initialized: RefCell<bool>,
+    initialized: AssertUnwindSafe<Cell<bool>>,
     env: Env,
 }
 
 impl DurableObject for Counter {
     fn new(state: State, env: Env) -> Self {
         Self {
-            count: RefCell::new(0),
-            unstored_count: RefCell::new(0),
-            initialized: RefCell::new(false),
+            count: AssertUnwindSafe(Cell::new(0)),
+            unstored_count: AssertUnwindSafe(Cell::new(0)),
+            initialized: AssertUnwindSafe(Cell::new(false)),
             state,
             env,
         }
     }
 
     async fn fetch(&self, req: Request) -> Result<Response> {
-        if !*self.initialized.borrow() {
-            *self.initialized.borrow_mut() = true;
-            *self.count.borrow_mut() = self.state.storage().get("count").await?.unwrap_or(0);
+        if !self.initialized.get() {
+            self.initialized.set(true);
+            self.count
+                .set(self.state.storage().get("count").await?.unwrap_or(0));
         }
 
         if req.path().eq("/ws") {
@@ -49,15 +51,15 @@ impl DurableObject for Counter {
                 .empty());
         }
 
-        *self.unstored_count.borrow_mut() += 1;
-        *self.count.borrow_mut() += 10;
-        let count = *self.count.borrow();
+        self.unstored_count.set(self.unstored_count.get() + 1);
+        self.count.set(self.count.get() + 10);
+        let count = self.count.get();
         self.state.storage().put("count", count).await?;
 
         Response::ok(format!(
             "[durable_object]: self.count: {}, self.unstored_count: {}, secret value: {}",
-            self.count.borrow(),
-            self.unstored_count.borrow(),
+            self.count.get(),
+            self.unstored_count.get(),
             self.env.secret("SOME_SECRET")?
         ))
     }
@@ -134,7 +136,7 @@ pub async fn handle_websocket(req: Request, env: Env, _data: SomeSharedData) ->
     let do_ws = res.websocket().expect("server did not accept websocket");
     do_ws.accept()?;
 
-    wasm_bindgen_futures::spawn_local(async move {
+    js_sys::futures::spawn_local(async move {
         let event_stream = server.events().expect("could not open stream");
         let do_event_stream = do_ws.events().expect("could not open stream");
 

test/src/container.rs

@@ -1,6 +1,8 @@
 use serde::Serialize;
+use std::cell::Cell;
+use std::collections::HashMap;
 use std::convert::TryFrom;
-use std::{cell::RefCell, collections::HashMap};
+use std::panic::AssertUnwindSafe;
 use worker::DurableObject;
 
 use worker::{
@@ -13,14 +15,14 @@ use worker::{
 #[durable_object]
 pub struct MyClass {
     state: State,
-    number: RefCell<usize>,
+    number: AssertUnwindSafe<Cell<usize>>,
 }
 
 impl DurableObject for MyClass {
     fn new(state: State, _env: Env) -> Self {
         Self {
             state,
-            number: RefCell::new(0),
+            number: AssertUnwindSafe(Cell::new(0)),
         }
     }
 
@@ -153,13 +155,14 @@ impl DurableObject for MyClass {
                         );
                     }
 
-                    *self.number.borrow_mut() = storage.get("count").await?.unwrap_or(0) + 1;
+                    self.number
+                        .set(storage.get("count").await?.unwrap_or(0) + 1);
 
                     storage.delete_all().await?;
 
-                    let count = *self.number.borrow();
+                    let count = self.number.get();
                     storage.put("count", count).await?;
-                    Response::ok(self.number.borrow().to_string())
+                    Response::ok(self.number.get().to_string())
                 }
                 "/transaction" => {
                     Response::error("transactional storage API is still unstable", 501)
@@ -178,20 +181,20 @@ impl DurableObject for MyClass {
 pub struct AnotherClass {
     #[allow(unused)]
     state: State,
-    counter: RefCell<i32>,
+    counter: AssertUnwindSafe<Cell<i32>>,
 }
 
 impl DurableObject for AnotherClass {
     fn new(state: State, _env: Env) -> Self {
         Self {
             state,
-            counter: RefCell::new(0),
+            counter: AssertUnwindSafe(Cell::new(0)),
         }
     }
 
     async fn fetch(&self, _req: Request) -> Result<Response> {
-        *self.counter.borrow_mut() += 1;
-        Response::ok(format!("Counter: {}", self.counter.borrow()))
+        self.counter.set(self.counter.get() + 1);
+        Response::ok(format!("Counter: {}", self.counter.get()))
     }
 }