Also remove async destructors

Author: lukewagner

design/mvp/Binary.md

@@ -215,8 +215,6 @@ label'        ::= len:<u32> l:<label>                     => l    (if len = |l|)
 valtype       ::= i:<typeidx>                             => i
                 | pvt:<primvaltype>                       => pvt
 resourcetype  ::= 0x3f v:<valtype> f?:<core:funcidx>?     => (resource (rep v) (dtor f)?)
-                | 0x3e v:<valtype> f:<core:funcidx>
-                                   cb?:<core:funcidx>?    => (resource (rep v) (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)*

design/mvp/CanonicalABI.md

@@ -1290,14 +1290,10 @@ the `rt` field of `ResourceHandle` (above) and thus resource type equality is
 class ResourceType(Type):
   impl: ComponentInstance
   dtor: Optional[Callable]
-  dtor_async: bool
-  dtor_callback: Optional[Callable]
 
-  def __init__(self, impl, dtor = None, dtor_async = False, dtor_callback = None):
+  def __init__(self, impl, dtor = None):
     self.impl = impl
     self.dtor = dtor
-    self.dtor_async = dtor_async
-    self.dtor_callback = dtor_callback
 ```
 
 
@@ -3912,22 +3908,22 @@ def canon_resource_drop(rt, i):
       if rt.dtor:
         rt.dtor(h.rep)
     else:
-      caller_opts = CanonicalOptions(async_ = False)
-      callee_opts = CanonicalOptions(async_ = rt.dtor_async, callback = rt.dtor_callback)
-      ft = FuncType([U32Type()],[], async_ = False)
+      ft = FuncType([U32Type()], [], async_ = False)
       dtor = rt.dtor or (lambda rep: [])
-      callee = inst.store.lift(dtor, ft, callee_opts, rt.impl)
-      caller = inst.store.lower(callee, ft, caller_opts, inst)
+      opts = CanonicalOptions(async_ = False)
+      callee = inst.store.lift(dtor, ft, opts, rt.impl)
+      caller = inst.store.lower(callee, ft, opts, inst)
       caller([h.rep])
   else:
     h.borrow_scope.num_borrows -= 1
   return []
 ```
-The call to a resource's destructor is defined as a non-`async`-lowered,
-non-`async`-typed function call to a possibly-`async`-lifted callee, passing
-the private `i32` representation as a parameter. Thus, destructors *may* block
-on I/O, but only after they `task.return`, ensuring that `resource.drop` never
-blocks.
+The call to a resource's destructor passes the `i32` representation value that
+was previously supplied to `resource.new`. The call works like a normal
+non-`async` cross-component call, using the same `canon_lift` and `canon_lower`
+rules to, for example, catch reentrance. Because the type, lifting and
+lowering are all non-`async`, the destructor may not block. However, the
+destructor may spawn a cooperative thread that does.
 
 Since there are valid reasons to call `resource.drop` in the same component
 instance that defined the resource, which would otherwise trap at the

design/mvp/Explainer.md

@@ -570,9 +570,7 @@ defvaltype    ::= bool
 valtype       ::= <typeidx>
                 | <defvaltype>
 resourcetype  ::= (resource (rep i32) (dtor <core:funcidx>)?)
-                | (resource (rep i32) (dtor async <core:funcidx> (callback <core:funcidx>)?)?) 🚝
                 | (resource (rep i64) (dtor <core:funcidx>)?) 🐘
-                | (resource (rep i64) (dtor async <core:funcidx> (callback <core:funcidx>)?)?) 🚝🐘
 functype      ::= (func async? (param "<label>" <valtype>)* (result <valtype>)?)
 componenttype ::= (component <componentdecl>*)
 instancetype  ::= (instance <instancedecl>*)
@@ -814,9 +812,8 @@ is currently fixed to `i32` or `i64`, but will potentially be relaxed to include
 other types. When the last handle to a resource is dropped, the resource's
 destructor function specified by the `dtor` immediate will be called (if
 present), allowing the implementing component to perform clean-up like freeing
-linear memory allocations. Destructors can be declared `async`, with the same
-meaning for the `async` and `callback` immediates as described below for `canon
-lift`. A destructor for a `resource (rep $T)` must have type `($T) -> ()`.
+linear memory allocations. A destructor for a `resource (rep $T)` must have type
+`($T) -> ()`.
 
 The `instance` type constructor describes a list of named, typed definitions
 that can be imported or exported by a component. Informally, instance types

design/mvp/canonical-abi/definitions.py

@@ -686,14 +686,10 @@ def __init__(self, rt, rep, own, borrow_scope = None):
 class ResourceType(Type):
   impl: ComponentInstance
   dtor: Optional[Callable]
-  dtor_async: bool
-  dtor_callback: Optional[Callable]
 
-  def __init__(self, impl, dtor = None, dtor_async = False, dtor_callback = None):
+  def __init__(self, impl, dtor = None):
     self.impl = impl
     self.dtor = dtor
-    self.dtor_async = dtor_async
-    self.dtor_callback = dtor_callback
 
 ### Waitable State
 
@@ -2249,12 +2245,11 @@ def canon_resource_drop(rt, i):
       if rt.dtor:
         rt.dtor(h.rep)
     else:
-      caller_opts = CanonicalOptions(async_ = False)
-      callee_opts = CanonicalOptions(async_ = rt.dtor_async, callback = rt.dtor_callback)
-      ft = FuncType([U32Type()],[], async_ = False)
+      ft = FuncType([U32Type()], [], async_ = False)
       dtor = rt.dtor or (lambda rep: [])
-      callee = inst.store.lift(dtor, ft, callee_opts, rt.impl)
-      caller = inst.store.lower(callee, ft, caller_opts, inst)
+      opts = CanonicalOptions(async_ = False)
+      callee = inst.store.lift(dtor, ft, opts, rt.impl)
+      caller = inst.store.lower(callee, ft, opts, inst)
       caller([h.rep])
   else:
     h.borrow_scope.num_borrows -= 1