Make 'async' part of the function type, not a hint

Author: lukewagner

design/mvp/Binary.md

@@ -216,6 +216,7 @@ valtype       ::= i:<typeidx>                             => i
 resourcetype  ::= 0x3f 0x7f f?:<funcidx>?                 => (resource (rep i32) (dtor f)?)
                 | 0x3e 0x7f f:<funcidx> cb?:<funcidx>?    => (resource (rep i32) (dtor async f (callback cb)?)) 🚝
 functype      ::= 0x40 ps:<paramlist> rs:<resultlist>     => (func ps rs)
+                | 0x43 ps:<paramlist> rs:<resultlist>     => (func async ps rs)
 paramlist     ::= lt*:vec(<labelvaltype>)                 => (param lt)*
 resultlist    ::= 0x00 t:<valtype>                        => (result t)
                 | 0x01 0x00                               =>
@@ -288,7 +289,6 @@ canon    ::= 0x00 0x00 f:<core:funcidx> opts:<opts> ft:<typeidx> => (canon lift
            | 0x01 0x00 f:<funcidx> opts:<opts>                   => (canon lower f opts (core func))
            | 0x02 rt:<typeidx>                                   => (canon resource.new rt (core func))
            | 0x03 rt:<typeidx>                                   => (canon resource.drop rt (core func))
-           | 0x07 rt:<typeidx>                                   => (canon resource.drop rt async (core func)) 🚝
            | 0x04 rt:<typeidx>                                   => (canon resource.rep rt (core func))
            | 0x08                                                => (canon backpressure.set (core func)) 🔀✕
            | 0x24                                                => (canon backpressure.inc (core func)) 🔀

design/mvp/Explainer.md

@@ -568,7 +568,7 @@ valtype       ::= <typeidx>
                 | <defvaltype>
 resourcetype  ::= (resource (rep i32) (dtor <funcidx>)?)
                 | (resource (rep i32) (dtor async <funcidx> (callback <funcidx>)?)?) 🚝
-functype      ::= (func (param "<label>" <valtype>)* (result <valtype>)?)
+functype      ::= (func async? (param "<label>" <valtype>)* (result <valtype>)?)
 componenttype ::= (component <componentdecl>*)
 instancetype  ::= (instance <instancedecl>*)
 componentdecl ::= <importdecl>
@@ -737,11 +737,8 @@ are useful for:
 
 A `future<T>` asynchronously delivers exactly one `T` value from a source to a
 destination, unless the destination signals that it doesn't want the `T` value
-any more. Because [all imports can be called asynchronously][summary], futures
-are not necessary to express a traditional `async` function -- all functions
-are effectively `async`. Instead futures are useful in more advanced scenarios
-where a parameter or result value may not be ready at the same time as the
-other synchronous parameters or results.
+any more. When function types are marked [`async`][summary] directly,
+...TODO... `future<T>` is only needed to express *additional* concurrency.
 
 The `T` element type of `stream` and `future` is an optional `valtype`. As with
 variant-case payloads and function results, when `T` is absent, the "value(s)"
@@ -793,7 +790,9 @@ shared-nothing functions, resources, components, and component instances:
 
 The `func` type constructor describes a component-level function definition
 that takes a list of `valtype` parameters with [strongly-unique] names and
-optionally returns a `valtype`.
+optionally returns a `valtype`. The optional `async` effect type indicates that
+the function may block (calling a blocking built-in like `waitable-set.wait` or
+synchronously calling an imported `async` function).
 
 The `resource` type constructor creates a fresh type for each instance of the
 containing component (with "freshness" and its interaction with general
@@ -1413,7 +1412,6 @@ dynamically interact with Canonical ABI entities like resources,
 canon ::= ...
         | (canon resource.new <typeidx> (core func <id>?))
         | (canon resource.drop <typeidx> (core func <id>?))
-        | (canon resource.drop <typeidx> async (core func <id>?)) 🚝
         | (canon resource.rep <typeidx> (core func <id>?))
         | (canon context.get <valtype> <u32> (core func <id>?)) 🔀
         | (canon context.set <valtype> <u32> (core func <id>?)) 🔀
@@ -1482,32 +1480,16 @@ For details, see [`canon_resource_new`] in the Canonical ABI explainer.
 
 ###### `resource.drop`
 
-When the `async` immediate is false:
-
 | Synopsis                   |                                    |
 | -------------------------- | ---------------------------------- |
 | Approximate WIT signature  | `func<T>(t: T)`                    |
 | Canonical ABI signature    | `[t:i32] -> []`                    |
 
-🚝 When the `async` immediate is true:
-
-| Synopsis                   |                                    |
-| -------------------------- | ---------------------------------- |
-| Approximate WIT signature  | `func<T>(t: T) -> option<subtask>` |
-| Canonical ABI signature    | `[t:i32] -> [i32]`                 |
-
 The `resource.drop` built-in drops a resource handle `t` (with resource type
 `T`). If the dropped handle owns the resource, the resource's `dtor` is called,
 if present. Validation only allows `resource.rep T` to be used within the
 component that defined `T`.
 
-When the `async` immediate is true, the returned value indicates whether the
-drop completed eagerly, or if not, identifies the in-progress drop.
-
-In the Canonical ABI, the returned `i32` is either `0` (if the drop completed
-eagerly) or the index of the in-progress drop subtask (representing the
-in-progress `dtor` call).
-
 For details, see [`canon_resource_drop`] in the Canonical ABI explainer.
 
 ###### `resource.rep`
@@ -2521,12 +2503,9 @@ importname        ::= <exportname>
                     | <urlname>
                     | <hashname>
 plainname         ::= <label>
-                    | '[async]' <label> 🔀
                     | '[constructor]' <label>
                     | '[method]' <label> '.' <label>
-                    | '[async method]' <label> '.' <label> 🔀
                     | '[static]' <label> '.' <label>
-                    | '[async static]' <label> '.' <label> 🔀
 label             ::= <fragment>
                     | <label> '-' <fragment>
 fragment          ::= <word>
@@ -2671,10 +2650,10 @@ annotations trigger additional type-validation rules (listed in
 * Similarly, an import or export named `[method]R.foo` must be a function whose
   first parameter must be `(param "self" (borrow $R))`.
 
-When a function is annotated with `async`, bindings generators are expected to
+When a function's type is `async`, bindings generators are expected to
 emit whatever asynchronous language construct is appropriate (such as an
-`async` function in JS, Python or Rust). Note the absence of
-`[async constructor]`. See the [concurrency explainer] for more details.
+`async` function in JS, Python or Rust). See the [concurrency explainer] for
+more details.
 
 The `label` production used inside `plainname` as well as the labels of
 `record` and `variant` types are required to have [kebab case]. The reason for
@@ -2806,7 +2785,8 @@ Thus, the following names are strongly-unique:
 * `foo`, `foo-bar`, `[constructor]foo`, `[method]foo.bar`, `[method]foo.baz`
 
 but attempting to add *any* of the following names would be a validation error:
-* `foo`, `foo-BAR`, `[constructor]foo-BAR`, `[method]foo.foo`, `[async]foo`, `[method]foo.BAR`
+* `foo`, `foo-BAR`, `[constructor]foo-BAR`, `[method]foo.foo`,
+  `[static]foo.foo`, `[method]foo.BAR`
 
 Note that additional validation rules involving types apply to names with
 annotations. For example, the validation rules for `[constructor]foo` require

design/mvp/WIT.md

@@ -1450,16 +1450,11 @@ named-type-list ::= ϵ
 named-type ::= id ':' ty
 ```
 
-The optional `async` hint in a WIT function type indicates that the callee
-is expected to block and thus the caller should emit whatever asynchronous
-language bindings are appropriate (e.g., in JS, Python, C# or Rust, an `async`
-WIT function would emit an `async` JS/Python/C#/Rust function). Because `async`
-is just a hint and not enforced by the runtime, it is technically possible for
-a non-`async` callee to block. In that case, though, it is the *callee's* fault
-for any resultant loss of concurrency, not the caller's. Thus, `async` is
-primarily intended to document expectations in a way that can be taken
-advantage of by bindings generators. (For more details, see the [concurrency
-explainer](Concurrency.md).)
+The optional `async` prefix in a WIT function type indicates that the callee is
+allowed to block and thus the caller should emit the appropriate asynchronous
+source-language bindings (e.g., in JS, Python, C# or Rust, an `async` WIT
+function would emit an `async` JS/Python/C#/Rust function). (For more details,
+see the [concurrency explainer](Concurrency.md).)
 
 
 ## Item: `use`
@@ -1689,8 +1684,8 @@ resource-method ::= func-item
                   | 'constructor' param-list ';'
 ```
 
-The optional `async` hint on `static` functions has the same meaning as
-in a non-`static` `func-item`.
+The optional `async` on `static` functions has the same meaning as in a
+non-`static` `func-item`.
 
 The syntax for handle types is presented [below](#handles).
 

design/mvp/canonical-abi/definitions.py

@@ -88,6 +88,7 @@ class InstanceType(ExternType):
 class FuncType(ExternType):
   params: list[tuple[str,ValType]]
   result: list[ValType|tuple[str,ValType]]
+  async_: bool = False
   def param_types(self):
     return self.extract_types(self.params)
   def result_type(self):
@@ -557,8 +558,13 @@ def trap_if_on_the_stack(self, inst):
   def needs_exclusive(self):
     return not self.opts.async_ or self.opts.callback
 
+  def must_not_suspend(self):
+    return not self.ft.async_ and self.state != Task.State.RESOLVED
+
   def enter(self, thread):
     assert(thread in self.threads and thread.task is self)
+    if not self.ft.async_:
+      return True
     def has_backpressure():
       return self.inst.backpressure > 0 or (self.needs_exclusive() and self.inst.exclusive)
     if has_backpressure() or self.inst.num_waiting_to_enter > 0:
@@ -575,6 +581,8 @@ def has_backpressure():
 
   def exit(self):
     assert(len(self.threads) > 0)
+    if not self.ft.async_:
+      return
     if self.needs_exclusive():
       assert(self.inst.exclusive)
       self.inst.exclusive = False
@@ -2010,12 +2018,17 @@ def thread_func(thread):
       inst.exclusive = False
       match code:
         case CallbackCode.YIELD:
-          event = task.yield_until(lambda: not inst.exclusive, thread, cancellable = True)
+          if thread.task.must_not_suspend():
+            event = (EventCode.NONE, 0, 0)
+          else:
+            event = task.yield_until(lambda: not inst.exclusive, thread, cancellable = True)
         case CallbackCode.WAIT:
+          trap_if(thread.task.must_not_suspend())
           wset = inst.table.get(si)
           trap_if(not isinstance(wset, WaitableSet))
           event = task.wait_until(lambda: not inst.exclusive, thread, wset, cancellable = True)
         case CallbackCode.POLL:
+          trap_if(thread.task.must_not_suspend())
           wset = inst.table.get(si)
           trap_if(not isinstance(wset, WaitableSet))
           event = task.poll_until(lambda: not inst.exclusive, thread, wset, cancellable = True)
@@ -2056,6 +2069,7 @@ def call_and_trap_on_throw(callee, thread, args):
 
 def canon_lower(opts, ft, callee: FuncInst, thread, flat_args):
   trap_if(not thread.task.inst.may_leave)
+  trap_if(ft.async_ and not opts.async_ and thread.task.must_not_suspend())
   subtask = Subtask()
   cx = LiftLowerContext(opts, thread.task.inst, subtask)
 
@@ -2095,6 +2109,7 @@ def on_resolve(result):
       flat_results = lower_flat_values(cx, max_flat_results, result, ft.result_type(), flat_args)
 
   subtask.callee = callee(thread.task, on_start, on_resolve)
+  assert(ft.async_ or subtask.resolved())
 
   if not opts.async_:
     if not subtask.resolved():
@@ -2129,31 +2144,30 @@ def canon_resource_new(rt, thread, rep):
 
 ### `canon resource.drop`
 
-def canon_resource_drop(rt, async_, thread, i):
+def canon_resource_drop(rt, thread, i):
   trap_if(not thread.task.inst.may_leave)
   inst = thread.task.inst
   h = inst.table.remove(i)
   trap_if(not isinstance(h, ResourceHandle))
   trap_if(h.rt is not rt)
   trap_if(h.num_lends != 0)
-  flat_results = [] if not async_ else [0]
   if h.own:
     assert(h.borrow_scope is None)
     if inst is rt.impl:
       if rt.dtor:
         rt.dtor(h.rep)
     else:
       if rt.dtor:
-        caller_opts = CanonicalOptions(async_ = async_)
+        caller_opts = CanonicalOptions(async_ = False)
         callee_opts = CanonicalOptions(async_ = rt.dtor_async, callback = rt.dtor_callback)
-        ft = FuncType([U32Type()],[])
+        ft = FuncType([U32Type()],[], async_ = False)
         callee = partial(canon_lift, callee_opts, rt.impl, ft, rt.dtor)
-        flat_results = canon_lower(caller_opts, ft, callee, thread, [h.rep])
+        [] = canon_lower(caller_opts, ft, callee, thread, [h.rep])
       else:
         thread.task.trap_if_on_the_stack(rt.impl)
   else:
     h.borrow_scope.num_borrows -= 1
-  return flat_results
+  return []
 
 ### `canon resource.rep`
 
@@ -2231,6 +2245,7 @@ def canon_waitable_set_new(thread):
 
 def canon_waitable_set_wait(cancellable, mem, thread, si, ptr):
   trap_if(not thread.task.inst.may_leave)
+  trap_if(thread.task.must_not_suspend())
   wset = thread.task.inst.table.get(si)
   trap_if(not isinstance(wset, WaitableSet))
   event = thread.task.wait_until(lambda: True, thread, wset, cancellable)
@@ -2247,6 +2262,7 @@ def unpack_event(mem, thread, ptr, e: EventTuple):
 
 def canon_waitable_set_poll(cancellable, mem, thread, si, ptr):
   trap_if(not thread.task.inst.may_leave)
+  trap_if(thread.task.must_not_suspend())
   wset = thread.task.inst.table.get(si)
   trap_if(not isinstance(wset, WaitableSet))
   event = thread.task.poll_until(lambda: True, thread, wset, cancellable)
@@ -2281,6 +2297,7 @@ def canon_waitable_join(thread, wi, si):
 
 def canon_subtask_cancel(async_, thread, i):
   trap_if(not thread.task.inst.may_leave)
+  trap_if(not async_ and thread.task.must_not_suspend())
   subtask = thread.task.inst.table.get(i)
   trap_if(not isinstance(subtask, Subtask))
   trap_if(subtask.resolve_delivered())
@@ -2337,6 +2354,7 @@ def canon_stream_write(stream_t, opts, thread, i, ptr, n):
 
 def stream_copy(EndT, BufferT, event_code, stream_t, opts, thread, i, ptr, n):
   trap_if(not thread.task.inst.may_leave)
+  trap_if(not opts.async_ and thread.task.must_not_suspend())
   e = thread.task.inst.table.get(i)
   trap_if(not isinstance(e, EndT))
   trap_if(e.shared.t != stream_t.t)
@@ -2388,6 +2406,7 @@ def canon_future_write(future_t, opts, thread, i, ptr):
 
 def future_copy(EndT, BufferT, event_code, future_t, opts, thread, i, ptr):
   trap_if(not thread.task.inst.may_leave)
+  trap_if(not opts.async_ and thread.task.must_not_suspend())
   e = thread.task.inst.table.get(i)
   trap_if(not isinstance(e, EndT))
   trap_if(e.shared.t != future_t.t)
@@ -2438,6 +2457,8 @@ def canon_future_cancel_write(future_t, async_, thread, i):
 
 def cancel_copy(EndT, event_code, stream_or_future_t, async_, thread, i):
   trap_if(not thread.task.inst.may_leave)
+  # TODO: maybe allow?
+  trap_if(not async_ and thread.task.must_not_suspend())
   e = thread.task.inst.table.get(i)
   trap_if(not isinstance(e, EndT))
   trap_if(e.shared.t != stream_or_future_t.t)
@@ -2521,6 +2542,7 @@ def canon_thread_switch_to(cancellable, thread, i):
 
 def canon_thread_suspend(cancellable, thread):
   trap_if(not thread.task.inst.may_leave)
+  trap_if(thread.task.must_not_suspend())
   if not thread.task.suspend(thread, cancellable):
     assert(cancellable)
     return [SuspendResult.CANCELLED]
@@ -2554,6 +2576,8 @@ def canon_thread_yield_to(cancellable, thread, i):
 
 def canon_thread_yield(cancellable, thread):
   trap_if(not thread.task.inst.may_leave)
+  if thread.task.must_not_suspend():
+    return [SuspsendResult.COMPLETED]
   event_code,_,_ = thread.task.yield_until(lambda: True, thread, cancellable)
   match event_code:
     case EventCode.NONE: