Switch _ to - in thread.{new-indirect,spawn-indirect,spawn-ref}

Author: lukewagner

design/mvp/Binary.md

@@ -323,13 +323,13 @@ canon    ::= 0x00 0x00 f:<core:funcidx> opts:<opts> ft:<typeidx> => (canon lift
            | 0x22                                                => (canon waitable-set.drop (core func)) 🔀
            | 0x23                                                => (canon waitable.join (core func)) 🔀
            | 0x26                                                => (canon thread.index (core func)) 🧵
-           | 0x27 ft:<typeidx> tbl:<core:tableidx>               => (canon thread.new_indirect ft tbl (core func)) 🧵
+           | 0x27 ft:<typeidx> tbl:<core:tableidx>               => (canon thread.new-indirect ft tbl (core func)) 🧵
            | 0x28 cancel?:<cancel?>                              => (canon thread.switch-to cancel? (core func)) 🧵
            | 0x29 cancel?:<cancel?>                              => (canon thread.suspend cancel? (core func)) 🧵
            | 0x2a                                                => (canon thread.resume-later (core func)) 🧵
            | 0x2b cancel?:<cancel?>                              => (canon thread.yield-to cancel? (core func)) 🧵
-           | 0x40 shared?:<sh?> ft:<typeidx>                     => (canon thread.spawn_ref shared? ft (core func)) 🧵②
-           | 0x41 shared?:<sh?> ft:<typeidx> tbl:<core:tableidx> => (canon thread.spawn_indirect shared? ft tbl (core func)) 🧵②
+           | 0x40 shared?:<sh?> ft:<typeidx>                     => (canon thread.spawn-ref shared? ft (core func)) 🧵②
+           | 0x41 shared?:<sh?> ft:<typeidx> tbl:<core:tableidx> => (canon thread.spawn-indirect shared? ft tbl (core func)) 🧵②
            | 0x42 shared?:<sh?>                                  => (canon thread.available-parallelism shared? (core func)) 🧵②
 async?   ::= 0x00                                                =>
            | 0x01                                                => async

design/mvp/CanonicalABI.md

@@ -59,7 +59,7 @@ specified here.
   * [`canon {stream,future}.cancel-{read,write}`](#-canon-streamfuturecancel-readwrite) 🔀
   * [`canon {stream,future}.drop-{readable,writable}`](#-canon-streamfuturedrop-readablewritable) 🔀
   * [`canon thread.index`](#-canon-threadindex) 🧵
-  * [`canon thread.new_indirect`](#-canon-threadnew_indirect) 🧵
+  * [`canon thread.new-indirect`](#-canon-threadnew-indirect) 🧵
   * [`canon thread.switch-to`](#-canon-threadswitch-to) 🧵
   * [`canon thread.suspend`](#-canon-threadsuspend) 🧵
   * [`canon thread.resume-later`](#-canon-threadresume-later) 🧵
@@ -68,8 +68,8 @@ specified here.
   * [`canon error-context.new`](#-canon-error-contextnew) 📝
   * [`canon error-context.debug-message`](#-canon-error-contextdebug-message) 📝
   * [`canon error-context.drop`](#-canon-error-contextdrop) 📝
-  * [`canon thread.spawn_ref`](#-canon-threadspawn_ref) 🧵②
-  * [`canon thread.spawn_indirect`](#-canon-threadspawn_indirect) 🧵②
+  * [`canon thread.spawn-ref`](#-canon-threadspawn-ref) 🧵②
+  * [`canon thread.spawn-indirect`](#-canon-threadspawn-indirect) 🧵②
   * [`canon thread.available-parallelism`](#-canon-threadavailable-parallelism) 🧵②
 
 ## Introduction
@@ -422,7 +422,7 @@ class ResourceType(Type):
 
 As described in the [concurrency explainer], threads are created both
 *implicitly*, when calling a component export (in `canon_lift` below), and
-*explicitly*, when core wasm code calls the `thread.new_indirect` built-in (in
+*explicitly*, when core wasm code calls the `thread.new-indirect` built-in (in
 `canon_thread_new_indirect` below). Threads are represented here by the
 `Thread` class and the [current thread] is represented by explicitly threading
 a reference to a `Thread` through all Core WebAssembly calls so that the
@@ -769,7 +769,7 @@ enforce the Canonical ABI rules associated with the callee as well as implement
 caller-requested cancellation. Each task contains 0..N threads that execute on
 behalf of the task, starting with the thread that is spawned to execute the
 exported function and transitively including additional threads spawned by that
-thread via `thread.new_indirect`.
+thread via `thread.new-indirect`.
 
 Tasks are represented here by the `Task` class and the [current task] is
 represented by the `Thread.task` field of the [current thread]. `Task`
@@ -4332,11 +4332,11 @@ def canon_thread_index(thread):
 ```
 
 
-### 🧵 `canon thread.new_indirect`
+### 🧵 `canon thread.new-indirect`
 
 For a canonical definition:
 ```wat
-(canon thread.new_indirect $ft $ftbl (core func $new_indirect))
+(canon thread.new-indirect $ft $ftbl (core func $new_indirect))
 ```
 validation specifies
 * `$ft` must refer to the type `(func (param $c i32))`
@@ -4623,11 +4623,11 @@ def canon_error_context_drop(thread, i):
 ```
 
 
-### 🧵② `canon thread.spawn_ref`
+### 🧵② `canon thread.spawn-ref`
 
 For a canonical definition:
 ```wat
-(canon thread.spawn_ref shared? $ft (core func $spawn_ref))
+(canon thread.spawn-ref shared? $ft (core func $spawn_ref))
 ```
 validation specifies:
 * `$ft` must refer to the type `(shared? (func (param $c i32)))` (see explanation below)
@@ -4642,7 +4642,7 @@ parallel with all other threads.
 > Note: ideally, a thread could be spawned with [arbitrary thread parameters].
 > Currently, that would require additional work in the toolchain to support so,
 > for simplicity, the current proposal simply fixes a single `i32` parameter
-> type. However, `thread.spawn_ref` could be extended to allow arbitrary thread
+> type. However, `thread.spawn-ref` could be extended to allow arbitrary thread
 > parameters in the future, once it's concretely beneficial to the toolchain.
 > The inclusion of `$ft` ensures backwards compatibility for when arbitrary
 > parameters are allowed.
@@ -4664,15 +4664,15 @@ part of adding a [GC ABI option] to the Canonical ABI and would work
 like `canon_thread_new_indirect` minus the table access and type check.
 
 
-### 🧵② `canon thread.spawn_indirect`
+### 🧵② `canon thread.spawn-indirect`
 
 For a canonical definition:
 ```wat
-(canon thread.spawn_indirect shared? $ft $tbl (core func $spawn_indirect))
+(canon thread.spawn-indirect shared? $ft $tbl (core func $spawn_indirect))
 ```
 validation specifies:
 * `$ft` must refer to the type `(shared? (func (param $c i32)))` is allowed
-  (see explanation in `thread.spawn_ref` above)
+  (see explanation in `thread.spawn-ref` above)
 * `$tbl` must refer to a shared table whose element type matches
   `(ref null (shared? func))`
 * `$spawn_indirect` is given type
@@ -4684,7 +4684,7 @@ immediate is present, the spawned thread is *preemptive* and able to execute in
 parallel with all other threads.
 
 Calling `$spawn_indirect` invokes the following function which simply fuses
-the `thread.new_indirect` and `thread.resume-later` built-ins, allowing
+the `thread.new-indirect` and `thread.resume-later` built-ins, allowing
 thread-creation to skip the intermediate "suspended" state transition.
 ```python
 def canon_thread_spawn_indirect(shared, ft, ftbl: Table[CoreFuncRef], thread, fi, c):

design/mvp/Concurrency.md

@@ -116,15 +116,15 @@ the stack.
 
 In addition to the *implicit* threads logically created for export calls, Core
 WebAssembly code can also *explicitly* create new green threads by calling the
-[`thread.new_indirect`] built-in. Regardless of how they were created, all
+[`thread.new-indirect`] built-in. Regardless of how they were created, all
 threads can call a set of Component Model-defined `thread.*` built-in functions
 (listed [below](#waiting)) to suspend themselves and/or resume other threads.
 These built-ins provide sufficient functionality to implement both the
 internally-scheduled "green thread" and the externally-scheduled "host thread"
 use cases mentioned in the [goals](#goals).
 
 Until the Core WebAssembly [shared-everything-threads] proposal allows Core
-WebAssembly function types to be annotated with `shared`, `thread.new_indirect`
+WebAssembly function types to be annotated with `shared`, `thread.new-indirect`
 can only call non-`shared` functions (via `i32` `(table funcref)` index, just
 like `call_indirect`) and thus currently all threads must execute
 [cooperatively] in a sequentially-interleaved fashion, switching between
@@ -237,7 +237,7 @@ where a **component store** is the top-level "thing" and analogous to a Core
 WebAssembly [store].
 
 The reason for the thread/task split is so that, when one thread creates a new
-thread by calling [`thread.new_indirect`], the new thread is contained by the
+thread by calling [`thread.new-indirect`], the new thread is contained by the
 task of the original thread. Thus there is an N:1 relationship between threads
 and tasks that ties N threads to the original export call (= "task") that
 transitively spawned those N threads. This relationship serves several purposes
@@ -275,9 +275,9 @@ natural place to store:
 2. a pointer to a struct used by the runtime to implement the language's
    thread-local features
 
-When threads are created explicitly by `thread.new_indirect`, the lifetime of
+When threads are created explicitly by `thread.new-indirect`, the lifetime of
 the thread-local storage array ends when the function passed to
-`thread.new_indirect` returns and thus any linear-memory allocations associated
+`thread.new-indirect` returns and thus any linear-memory allocations associated
 with the thread-local storage array should be eagerly freed by guest code right
 before returning. Similarly, since each call to an export logically creates a
 fresh thread, thread-local allocations can be eagerly released when this
@@ -502,7 +502,7 @@ will run out of other things to do and will need to wait for something else to
 happen by **suspending** itself until something else happens.
 
 The following three built-ins put threads into a suspended state:
-* [`thread.new_indirect`]: create a new thread that is initially suspended
+* [`thread.new-indirect`]: create a new thread that is initially suspended
   and continue executing the current thread
 * [`thread.switch-to`]: suspend the current thread and immediately resume a
   given thread
@@ -527,7 +527,7 @@ priority):
 
 These built-ins enable the "host thread" [use cases](#goals), allowing the
 embedder to nondeterministically control which thread is resumed when. In
-particular, [`pthread_create`] can be implemented using `thread.new_indirect`
+particular, [`pthread_create`] can be implemented using `thread.new-indirect`
 and either `thread.resume-later` or `thread.yield-to` (thereby allowing the
 pthreads implementation to choose whether to execute a new pthread eagerly or
 not).
@@ -549,7 +549,7 @@ In particular, the following built-ins allow building and using waitable sets:
   waitables in the given set has a pending event, return that event; otherwise
   return a sentinel "none" value
 
-Threads that are explicitly suspended (via `thread.new_indirect`,
+Threads that are explicitly suspended (via `thread.new-indirect`,
 `thread.switch-to` or `thread.suspend`) will stay suspended indefinitely until
 explicitly resumed (via `thread.switch-to`, `thread.resume-later`,
 `thread.yield-to`). Attempting to explicitly resume a thread that was *not*
@@ -1249,7 +1249,7 @@ comes after:
 [`waitable-set.wait`]: Explainer.md#-waitable-setwait
 [`waitable-set.poll`]: Explainer.md#-waitable-setpoll
 [`waitable.join`]: Explainer.md#-waitablejoin
-[`thread.new_indirect`]: Explainer.md#-threadnew_indirect
+[`thread.new-indirect`]: Explainer.md#-threadnew-indirect
 [`thread.index`]: Explainer.md#-threadindex
 [`thread.suspend`]: Explainer.md#-threadsuspend
 [`thread.switch-to`]: Explainer.md#-threadswitch-to

design/mvp/Explainer.md

@@ -1445,7 +1445,7 @@ canon ::= ...
         | (canon future.drop-readable <typeidx> (core func <id>?)) 🔀
         | (canon future.drop-writable <typeidx> (core func <id>?)) 🔀
         | (canon thread.index (core func <id>?)) 🧵
-        | (canon thread.new_indirect <typeidx> <core:tableidx> (core func <id>?)) 🧵
+        | (canon thread.new-indirect <typeidx> <core:tableidx> (core func <id>?)) 🧵
         | (canon thread.switch-to cancellable? (core func <id>?)) 🧵
         | (canon thread.suspend cancellable? (core func <id>?)) 🧵
         | (canon thread.resume-later (core func <id>?) 🧵
@@ -1454,8 +1454,8 @@ canon ::= ...
         | (canon error-context.new <canonopt>* (core func <id>?)) 📝
         | (canon error-context.debug-message <canonopt>* (core func <id>?)) 📝
         | (canon error-context.drop (core func <id>?)) 📝
-        | (canon thread.spawn_ref shared? <typeidx> (core func <id>?)) 🧵②
-        | (canon thread.spawn_indirect shared? <typeidx> <core:tableidx> (core func <id>?)) 🧵②
+        | (canon thread.spawn-ref shared? <typeidx> (core func <id>?)) 🧵②
+        | (canon thread.spawn-indirect shared? <typeidx> <core:tableidx> (core func <id>?)) 🧵②
         | (canon thread.available-parallelism (core func <id>?)) 🧵②
 ```
 
@@ -2055,20 +2055,20 @@ For details, see [`canon_stream_drop_readable`] in the Canonical ABI explainer.
 | Canonical ABI signature    | `[] -> [i32]`   |
 
 The `thread.index` built-in returns the index of the [current thread] in the
-component instance's table. While `thread.new_indirect` also returns the index
+component instance's table. While `thread.new-indirect` also returns the index
 of newly-created threads, threads created implicitly for export calls can only
 learn their index via `thread.index`.
 
 For details, see [`canon_thread_index`] in the Canonical ABI explainer.
 
-###### 🧵 `thread.new_indirect`
+###### 🧵 `thread.new-indirect`
 
 | Synopsis                   |                                                               |
 | -------------------------- | ------------------------------------------------------------- |
 | Approximate WIT signature  | `func<FuncT,tableidx>(fi: u32, c: FuncT.params[0]) -> thread` |
 | Canonical ABI signature    | `[fi:i32 c:i32] -> [i32]`                                     |
 
-The `thread.new_indirect` built-in adds a new thread to the current component
+The `thread.new-indirect` built-in adds a new thread to the current component
 instance's table, returning the index of the new thread. The function table
 supplied via [`core:tableidx`] is indexed by the `fi` operand and then
 dynamically checked to match the type `FuncT` (in the same manner as
@@ -2080,7 +2080,7 @@ Currently, `FuncT` must be `(func (param i32))` and thus `c` must always be an
 ABI is extended for [memory64] and [GC].
 
 As explained in the [concurrency explainer][waiting], a thread created by
-`thread.new_indirect` is initially in a suspended state and must be resumed
+`thread.new-indirect` is initially in a suspended state and must be resumed
 eagerly or lazily by [`thread.yield-to`](#-threadyield-to) or
 [`thread.resume-later`](#-threadresume-later), resp., to begin execution.
 
@@ -2202,30 +2202,30 @@ threads and threads implicitly created by non-`callback` `async`-lifted
 For details, see [waiting] in the concurrency explainer and
 [`canon_thread_yield`] in the Canonical ABI explainer.
 
-###### 🧵② `thread.spawn_ref`
+###### 🧵② `thread.spawn-ref`
 
 | Synopsis                   |                                                                    |
 | -------------------------- | ------------------------------------------------------------------ |
 | Approximate WIT signature  | `func<shared?,FuncT>(f: FuncT, c: FuncT.params[0]) -> bool`        |
 | Canonical ABI signature    | `shared? [f:(ref null (shared (func (param i32))) c:i32] -> [i32]` |
 
-The `thread.spawn_ref` built-in is an optimization, fusing a call to
+The `thread.spawn-ref` built-in is an optimization, fusing a call to
 `thread.new_ref` (assuming `thread.new_ref` was added as part of adding a
 [GC ABI option] to the Canonical ABI) with a call to
 [`thread.resume-later`](#-threadresume-later). This optimization is more
 impactful once given [shared-everything-threads] and thus gated on 🧵②.
 
 For details, see [`canon_thread_spawn_ref`] in the Canonical ABI explainer.
 
-###### 🧵② `thread.spawn_indirect`
+###### 🧵② `thread.spawn-indirect`
 
 | Synopsis                   |                                                                    |
 | -------------------------- | ------------------------------------------------------------------ |
 | Approximate WIT signature  | `func<shared?,FuncT,tableidx>(i: u32, c: FuncT.params[0]) -> bool` |
 | Canonical ABI signature    | `shared? [i:i32 c:i32] -> [i32]`                                   |
 
-The `thread.spawn_indirect` built-in is an optimization, fusing a call to
-[`thread.new_indirect`](#-threadnew_indirect) with a call to
+The `thread.spawn-indirect` built-in is an optimization, fusing a call to
+[`thread.new-indirect`](#-threadnew-indirect) with a call to
 [`thread.resume-later`](#-threadresume-later). This optimization is more
 impactful once given [shared-everything-threads] and thus gated on 🧵②.
 
@@ -3251,14 +3251,14 @@ For some use-case-focused, worked examples, see:
 [`canon_error_context_debug_message`]: CanonicalABI.md#-canon-error-contextdebug-message
 [`canon_error_context_drop`]: CanonicalABI.md#-canon-error-contextdrop
 [`canon_thread_index`]: CanonicalABI.md#-canon-threadindex
-[`canon_thread_new_indirect`]: CanonicalABI.md#-canon-threadnew_indirect
+[`canon_thread_new_indirect`]: CanonicalABI.md#-canon-threadnew-indirect
 [`canon_thread_suspend`]: CanonicalABI.md#-canon-threadsuspend
 [`canon_thread_switch_to`]: CanonicalABI.md#-canon-threadswitch-to
 [`canon_thread_resume_later`]: CanonicalABI.md#-canon-threadresume-later
 [`canon_thread_yield_to`]: CanonicalABI.md#-canon-threadyield-to
 [`canon_thread_yield`]: CanonicalABI.md#-canon-threadyield
-[`canon_thread_spawn_ref`]: CanonicalABI.md#-canon-threadspawn_ref
-[`canon_thread_spawn_indirect`]: CanonicalABI.md#-canon-threadspawn_indirect
+[`canon_thread_spawn_ref`]: CanonicalABI.md#-canon-threadspawn-ref
+[`canon_thread_spawn_indirect`]: CanonicalABI.md#-canon-threadspawn-indirect
 [`canon_thread_available_parallelism`]: CanonicalABI.md#-canon-threadavailable_parallelism
 [Shared-Nothing]: ../high-level/Choices.md
 [Use Cases]: ../high-level/UseCases.md

design/mvp/canonical-abi/definitions.py

@@ -2481,7 +2481,7 @@ def canon_thread_index(thread):
   assert(thread.index is not None)
   return [thread.index]
 
-### 🧵 `canon thread.new_indirect`
+### 🧵 `canon thread.new-indirect`
 
 @dataclass
 class CoreFuncRef: