Stream: git-wasmtime

Topic: wasmtime / issue #14949 Lent `own` handle can be dropped ...

view this post on Zulip Wasmtime GitHub notifications bot (Oct 22 2026 at 18:20):

alexcrichton added the wasm-proposal:component-model-async label to Issue #14949.

view this post on Zulip Wasmtime GitHub notifications bot (Oct 22 2026 at 18:20):

alexcrichton opened issue #14949:

This test:

;;! component_model_async = true

;; A lends `own` handle `h` to an async subtask in B. B drops its borrow,
;; calls `task.return` and then completes a future write that A is waiting
;; on. When A wakes up for the future, the subtask's RETURNED event hasn't
;; been delivered yet, so `h` is still lent and `resource.drop` must trap.

(component definition $C
  (import "host" (instance $host
    (export "resource1" (type $r (sub resource)))
    (export "[constructor]resource1" (func (param "r" u32) (result (own $r))))
  ))
  (alias export $host "resource1" (type $r))
  (alias export $host "[constructor]resource1" (func $resource1.ctor))

  (component $B
    (import "resource1" (type $r (sub resource)))
    (type $FT (future))
    (core func $resource.drop (canon resource.drop $r))
    (core func $task.return (canon task.return))
    (core func $future.read (canon future.read $FT async))
    (core func $future.drop-readable (canon future.drop-readable $FT))
    (core module $m
      (import "" "resource.drop" (func $resource.drop (param i32)))
      (import "" "task.return" (func $task.return))
      (import "" "future.read" (func $future.read (param i32 i32) (result i32)))
      (import "" "future.drop-readable" (func $future.drop-readable (param i32)))
      (global $b (mut i32) (i32.const 0))
      (global $rx (mut i32) (i32.const 0))
      (func (export "f") (param $x i32) (param $rx i32) (result i32)
        (global.set $b (local.get $x))
        (global.set $rx (local.get $rx))
        (i32.const 1 (; YIELD ;)))
      (func (export "cb") (param i32 i32 i32) (result i32)
        (call $resource.drop (global.get $b))
        (call $task.return)
        ;; Now complete A's pending future.write
        (if (i32.ne (call $future.read (global.get $rx) (i32.const 0)) (i32.const 0 (; COMPLETED ;)))
          (then unreachable))
        (call $future.drop-readable (global.get $rx))
        (i32.const 0 (; EXIT ;)))
    )
    (core instance $i (instantiate $m (with "" (instance
      (export "resource.drop" (func $resource.drop))
      (export "task.return" (func $task.return))
      (export "future.read" (func $future.read))
      (export "future.drop-readable" (func $future.drop-readable))
    ))))
    (func (export "f") async (param "x" (borrow $r)) (param "rx" $FT)
      (canon lift (core func $i "f") async (callback (core func $i "cb"))))
  )
  (instance $b (instantiate $B (with "resource1" (type $r))))

  (component $A
    (import "resource1" (type $r (sub resource)))
    (type $FT (future))
    (import "[constructor]resource1" (func $resource1.ctor (param "r" u32) (result (own $r))))
    (import "f" (func $f async (param "x" (borrow $r)) (param "rx" $FT)))
    (core func $resource1.ctor (canon lower (func $resource1.ctor)))
    (core func $f (canon lower (func $f) async))
    (core func $resource.drop (canon resource.drop $r))
    (core func $waitable-set.new (canon waitable-set.new))
    (core func $waitable.join (canon waitable.join))
    (core func $task.return (canon task.return))
    (core func $future.new (canon future.new $FT))
    (core func $future.write (canon future.write $FT async))
    (core module $m
      (import "" "task.return" (func $task.return))
      (import "" "[constructor]resource1" (func $resource1.ctor (param i32) (result i32)))
      (import "" "f" (func $f (param i32 i32) (result i32)))
      (import "" "resource.drop" (func $resource.drop (param i32)))
      (import "" "waitable-set.new" (func $waitable-set.new (result i32)))
      (import "" "waitable.join" (func $waitable.join (param i32 i32)))
      (import "" "future.new" (func $future.new (result i64)))
      (import "" "future.write" (func $future.write (param i32 i32) (result i32)))
      (global $h (mut i32) (i32.const 0))
      (func (export "run") (result i32)
        (local $s i32) (local $ws i32) (local $p i64) (local $tx i32)
        (global.set $h (call $resource1.ctor (i32.const 7)))
        (local.set $p (call $future.new))
        (local.set $tx (i32.wrap_i64 (i64.shr_u (local.get $p) (i64.const 32))))
        (local.set $s (call $f (global.get $h) (i32.wrap_i64 (local.get $p))))
        ;; B yielded, so the subtask must be STARTED.
        (if (i32.ne (i32.and (local.get $s) (i32.const 0xf)) (i32.const 1)) (then unreachable))
        ;; B isn't reading yet, so this blocks.
        (if (i32.ne (call $future.write (local.get $tx) (i32.const 0)) (i32.const -1))
          (then unreachable))
        (local.set $ws (call $waitable-set.new))
        (call $waitable.join (local.get $tx) (local.get $ws))
        (i32.or (i32.const 2 (; WAIT ;)) (i32.shl (local.get $ws) (i32.const 4))))
      (func (export "cb") (param $ev i32) (param $idx i32) (param $code i32) (result i32)
        (if (i32.ne (local.get $ev) (i32.const 5 (; FUTURE_WRITE ;))) (then unreachable))
        ;; The subtask's RETURNED event hasn't been delivered, so `h` is
        ;; still lent.
        (call $resource.drop (global.get $h))
        (call $task.return)
        (i32.const 0 (; EXIT ;)))
    )
    (core instance $i (instantiate $m (with "" (instance
      (export "[constructor]resource1" (func $resource1.ctor))
      (export "f" (func $f))
      (export "resource.drop" (func $resource.drop))
      (export "waitable-set.new" (func $waitable-set.new))
      (export "waitable.join" (func $waitable.join))
      (export "task.return" (func $task.return))
      (export "future.new" (func $future.new))
      (export "future.write" (func $future.write))
    ))))
    (func (export "run") async
      (canon lift (core func $i "run") async (callback (core func $i "cb"))))
  )
  (instance $a (instantiate $A (with "resource1" (type $r)) (with "[constructor]resource1" (func $resource1.ctor))
    (with "f" (func $b "f"))))
  (func (export "run") (alias export $a "run"))
)

(component instance $c $C)
(assert_trap (invoke "run") "cannot remove owned resource while borrowed")

fails with:

$ cargo run -- wast lend-released-early.wast
Error: failed to run script file 'lend-released-early.wast'

Caused by:
    0: failed directive on lend-released-early.wast:118
    1: expected trap, got Component([])

<details>
<summary>Details</summary>

In the canonical ABI, a caller's lends to a subtask are released in
Subtask.deliver_resolve, i.e. when the caller receives the RETURNED (or
RETURN_CANCELLED) event. Wasmtime releases them as soon as the callee calls
task.return/task.cancel (or an async host import's future completes or
is aborted), so the caller can resource.drop the lent own while the
terminal event is still undelivered. Wasmtime still checks the callee's
borrows are gone when it returns, so no borrow is left outstanding; it's a
missing trap.

</details>

Last updated: Oct 31 2026 at 23:03 UTC