add another deadlock test; add Trap::AsyncDeadlock variant

This creates a new `AsyncDeadlock` variant to the `Trap` enum, allowing
application code to downcast to `Trap` rather than do a string match to handle
the error programmatically.

Thanks to Luke Wagner for the additional test case.

Signed-off-by: Joel Dice <joel.dice@fermyon.com>

Author: dicej

crates/environ/src/trap_encoding.rs

@@ -92,6 +92,11 @@ pub enum Trap {
     /// Async-lifted export failed to produce a result by calling `task.return`
     /// before returning `STATUS_DONE` and/or after all host tasks completed.
     NoAsyncResult,
+
+    /// Async event loop deadlocked; i.e. it cannot make further progress given
+    /// that all host tasks have completed and any/all host-owned stream/future
+    /// handles have been dropped.
+    AsyncDeadlock,
     // if adding a variant here be sure to update the `check!` macro below
 }
 
@@ -129,6 +134,7 @@ impl Trap {
             CastFailure
             CannotEnterComponent
             NoAsyncResult
+            AsyncDeadlock
         }
 
         None
@@ -160,6 +166,7 @@ impl fmt::Display for Trap {
             CastFailure => "cast failure",
             CannotEnterComponent => "cannot enter component instance",
             NoAsyncResult => "async-lifted export failed to produce a result",
+            AsyncDeadlock => "deadlock detected: event loop cannot make further progress",
         };
         write!(f, "wasm trap: {desc}")
     }

crates/wasmtime/src/runtime/component/concurrent.rs

@@ -1734,10 +1734,9 @@ impl ComponentInstance {
                                 // chance to intervene by cancelling one or more
                                 // tasks and/or starting new tasks capable of
                                 // waking the existing ones.
-                                Poll::Ready(false) => Poll::Ready(Err(anyhow!(
-                                    "deadlock detected: event loop cannot \
-                                     make further progress"
-                                ))),
+                                Poll::Ready(false) => {
+                                    Poll::Ready(Err(anyhow!(crate::Trap::AsyncDeadlock)))
+                                }
                                 Poll::Pending => Poll::Pending,
                             };
                         } else {

tests/misc_testsuite/component-model-async/wait-forever2.wast

@@ -0,0 +1,76 @@
+;;! component_model_async = true
+;;! reference_types = true
+;;! gc_types = true
+;;! multi_memory = true
+
+(component
+  (component $C
+    (core module $Memory (memory (export "mem") 1))
+    (core instance $memory (instantiate $Memory))
+    (core module $CM
+      (import "" "mem" (memory 1))
+      (import "" "waitable-set.new" (func $waitable-set.new (result i32)))
+
+      (func (export "f") (result i32)
+        (local $ws i32)
+        ;; return WAIT on an empty waitable set
+        (local.set $ws (call $waitable-set.new))
+        (i32.or (i32.const 2 (; WAIT ;)) (i32.shl (local.get $ws) (i32.const 4)))
+      )
+      (func (export "cb") (param $event_code i32) (param $index i32) (param $payload i32) (result i32)
+        unreachable
+      )
+    )
+    (canon waitable-set.new (core func $waitable-set.new))
+    (core instance $cm (instantiate $CM (with "" (instance
+      (export "mem" (memory $memory "mem"))
+      (export "waitable-set.new" (func $waitable-set.new))
+    ))))
+    (func (export "f") (result u32) (canon lift
+      (core func $cm "f")
+      async (memory $memory "mem") (callback (func $cm "cb"))
+    ))
+  )
+
+  (component $D
+    (import "f" (func $f (result u32)))
+
+    (core module $Memory (memory (export "mem") 1))
+    (core instance $memory (instantiate $Memory))
+    (core module $DM
+      (import "" "mem" (memory 1))
+      (import "" "waitable.join" (func $waitable.join (param i32 i32)))
+      (import "" "waitable-set.new" (func $waitable-set.new (result i32)))
+      (import "" "waitable-set.wait" (func $waitable-set.wait (param i32 i32) (result i32)))
+      (import "" "f" (func $f (param i32 i32) (result i32)))
+
+      (func (export "g") (result i32)
+        (local $ws i32) (local $ret i32) (local $subtaski i32)
+        (local.set $ws (call $waitable-set.new))
+        (local.set $ret (call $f (i32.const 0) (i32.const 0)))
+        (local.set $subtaski (i32.shr_u (local.get $ret) (i32.const 4)))
+        (call $waitable.join (local.get $subtaski) (local.get $ws))
+        (call $waitable-set.wait (local.get $ws) (i32.const 0))
+        unreachable
+      )
+    )
+    (canon waitable.join (core func $waitable.join))
+    (canon waitable-set.new (core func $waitable-set.new))
+    (canon waitable-set.wait (memory $memory "mem") (core func $waitable-set.wait))
+    (canon lower (func $f) async (memory $memory "mem") (core func $f'))
+    (core instance $dm (instantiate $DM (with "" (instance
+      (export "mem" (memory $memory "mem"))
+      (export "waitable.join" (func $waitable.join))
+      (export "waitable-set.new" (func $waitable-set.new))
+      (export "waitable-set.wait" (func $waitable-set.wait))
+      (export "f" (func $f'))
+    ))))
+    (func (export "f") (result u32) (canon lift (core func $dm "g")))
+  )
+
+  (instance $c (instantiate $C))
+  (instance $d (instantiate $D (with "f" (func $c "f"))))
+  (func (export "f") (alias export $d "f"))
+)
+
+(assert_trap (invoke "f") "deadlock detected")