Split apart wasi.wit into multiple *.wit files

This commit refactors the monolithic `wasi.wit` file into multiple
files. I've taken some liberties in naming here so suggestions are
definitely welcome! I've resolved some TODO annotations as well about
`use`-ing types between interfaces. There are two issues remaining,
however:

* The `wasi-command` world still hardcodes `u32` because `world` items
  don't support `use` just yet. That isn't a hard limitation of WIT,
  however, it's just a temporary limitation of the implementation.

* The `wasi-clocks` interface defines the `wasi-future` type. This is
  due to a cyclic dependency where `wasi-future` is defined within
  `wasi-poll` which depends on `wasi-clocks` for types. I've left this
  to a future refactoring to probably have a `types` interface of some
  form somewhere.

Author: alexcrichton

Cargo.lock

@@ -60,3 +60,6 @@ overflow-checks = false
 
 [features]
 command = []
+
+[patch.crates-io]
+wit-parser = { git = 'https://github.com/alexcrichton/wasm-tools', branch = 'fix-wit-parser' }

Cargo.toml

@@ -12,7 +12,7 @@ type HostResult<T, E> = anyhow::Result<Result<T, E>>;
 
 wasmtime::component::bindgen!({
     path: "../wit",
-    world: "wasi",
+    world: "wasi-command",
     tracing: true,
     async: true,
 });

host/src/lib.rs

@@ -20,7 +20,7 @@ mod macros;
 
 mod bindings {
     wit_bindgen_guest_rust::generate!({
-        world: "wasi",
+        world: "wasi-command",
         no_std,
         raw_strings,
         unchecked,

src/lib.rs

@@ -0,0 +1,95 @@
+/// # WASI Clocks API
+///
+/// WASI Clocks is a clock API intended to let users query the current time and
+/// to measure elapsed time.
+///
+/// It is intended to be portable at least between Unix-family platforms and
+/// Windows.
+default interface wasi-clocks {
+  /// A monotonic clock is a clock which has an unspecified initial value, and
+  /// successive reads of the clock will produce non-decreasing values.
+  ///
+  /// It is intended for measuring elapsed time.
+  type monotonic-clock = u32
+
+  /// A wall clock is a clock which measures the date and time according to some
+  /// external reference.
+  ///
+  /// External references may be reset, so this clock is not necessarily
+  /// monotonic, making it unsuitable for measuring elapsed time.
+  ///
+  /// It is intended for reporting the current date and time for humans.
+  type wall-clock = u32
+
+  /// A timestamp in nanoseconds.
+  type instant = u64
+
+  /// A time and date in seconds plus nanoseconds.
+  record datetime {
+      seconds: u64,
+      nanoseconds: u32,
+  }
+
+  /// An asynchronous operation. See the comments on `wasi-future` in the
+  /// `wasi-poll` interface for details.
+  /// TODO: `use` the `wasi-poll` version
+  type wasi-future = u32
+
+  /// Read the current value of the clock.
+  ///
+  /// As this the clock is monotonic, calling this function repeatedly will produce
+  /// a sequence of non-decreasing values.
+  monotonic-clock-now: func(clock: monotonic-clock) -> instant
+
+  /// Query the resolution of the clock.
+  monotonic-clock-resolution: func(clock: monotonic-clock) -> instant
+
+  /// Read the current value of the clock.
+  ///
+  /// As this the clock is not monotonic, calling this function repeatedly will
+  /// not necessarily produce a sequence of non-decreasing values.
+  ///
+  /// The returned timestamps represent the number of seconds since
+  /// 1970-01-01T00:00:00Z, also known as [POSIX's Seconds Since the Epoch], also
+  /// known as [Unix Time].
+  ///
+  /// The nanoseconds field of the output is always less than 1000000000.
+  ///
+  /// [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16
+  /// [Unix Time]: https://en.wikipedia.org/wiki/Unix_time
+  wall-clock-now: func(clock: wall-clock) -> datetime
+
+  /// Query the resolution of the clock.
+  ///
+  /// The nanoseconds field of the output is always less than 1000000000.
+  wall-clock-resolution: func(clock: wall-clock) -> datetime
+
+  /// Closes a monotonic clock handle.
+  close-monotonic-clock: func(clock: monotonic-clock)
+
+  /// Closes a wall clock handle.
+  close-wall-clock: func(clock: wall-clock)
+}
+
+/// # WASI Default Clocks API
+///
+/// WASI Default Clocks provides value-exports of clock handles for monotonic
+/// and a wall-clock time, suitable for general-purpose application needs.
+interface wasi-default-clocks {
+  use self.wasi-clocks.{monotonic-clock, wall-clock}
+
+  /// Return a default monotonic clock, suitable for general-purpose application
+  /// needs.
+  ///
+  /// This allocates a new handle, so applications with frequent need of a clock
+  /// handle should call this function once and reuse the handle instead of
+  /// calling this function each time.
+  default-monotonic-clock: func() -> monotonic-clock
+
+  /// Return a default wall clock, suitable for general-purpose application
+  /// needs.
+  ///
+  /// This allocates a new handle, so applications with frequent need of a clock
+  /// handle should call this function once and reuse the handle instead of
+  default-wall-clock: func() -> wall-clock
+}

wit/wasi-clocks.wit

@@ -0,0 +1,19 @@
+default world wasi-command {
+  import wasi-clocks: pkg.wasi-clocks
+  import wasi-default-clocks: pkg.wasi-clocks.wasi-default-clocks
+  import wasi-logging: pkg.wasi-logging
+  import wasi-stderr: pkg.wasi-stderr
+  import wasi-filesystem: pkg.wasi-filesystem
+  import wasi-random: pkg.wasi-random
+  import wasi-poll: pkg.wasi-poll
+  import wasi-tcp: pkg.wasi-tcp
+  import wasi-exit: pkg.wasi-exit
+
+  export command: func(
+    stdin: u32, // TODO `use` from `wasi-poll`
+    stdout: u32, // TODO: `use` from `wasi-poll`
+    args: list<string>,
+    env-vars: list<tuple<string, string>>,
+    preopens: list<tuple<u32, string>> // TODO: `use` from `wasi-filesystem`
+  ) -> result
+}

wit/wasi-command.wit

@@ -0,0 +1,4 @@
+default interface wasi-exit {
+  /// Exit the curerent instance and any linked instances.
+  exit: func(status: result)
+}