Add support to wit-component to polyfill WASI

This commit is an addition to the `wit-component` tool to be able to
polyfill WASI imports today using `wasi_snapshot_preview1` with a
component-model-using interface in the future. This is a large extension
to the functionality of `wit-component` internally since the generated
component is much "fancier".

The support in this commit is modeled as the addition of "adapter
modules" into the `wit-component` tool. An adapter module is understood
to translate from some core-wasm ABI into a component-model using ABI.
The intention is that for any previous API prior to the component model
an adapter module could be written which would translate from the prior
API to the new API. For example in WASI today there is:

    (@interface func (export "random_get")
      (param $buf (@WitX pointer u8))
      (param $buf_len $size)
      (result $error (expected (error $errno)))
    )

whereas a component-model-using API would look more like:

    random-get: func(size: u32) -> list<u8>

This component-model version can be adapted with a module such as:

    (module $wasi_snapshot_preview1
      (import "new-wasi" "random_get" (func $new_random_get (param i32 i32)))
      (import "env" "memory" (memory 0))

      (global $last_ptr (mut i32) i32.const 0)

      (func (export "random_get") (param i32 i32) (result i32)
        ;; store buffer pointer in a saved global for `cabi_realloc`
        ;; later
        (global.set $last_ptr (local.get 0))

        ;; 1st argument: the `size: u32`
        local.get 1

        ;; 2nd argument: return pointer for `list<u8>`
        i32.const 8

        call $new_random_get

        ;; return a "success" return code
        i32.const 0
      )

      ;; When the canonical ABI allocates space for the list return value
      ;; return the original buffer pointer to place it directly in the
      ;; target buffer
      (func (export "cabi_realloc") (param i32 i32 i32 i32) (result i32)
        global.get $last_ptr)
    )

Using this adapter module the internal structure of the generated
component can be done such that everything is wired up in all the right
places meaning that when the original module calls
`wasi_snapshot_preview1::random_get` it actually calls this shim module
which then calls the actual `new-wasi::random_get` import. There's a few
details I'm glossing over here like the stack used by the shim module
but this suffices to describe the general shape.

My plan in the future is to use this support to generate a component
from all test cases that this repository supports. That means that,
specifically for `wit-bindgen` tests, a fresh new interface representing
"future WASI" will be created and the WASI functions used by tests will
be adapted via this adapter module. In this manner components will now
be generated for all tests and then the next step is bytecodealliance#314, actually
ingesting these components into hosts.

Author: alexcrichton

Cargo.lock

@@ -27,3 +27,7 @@ wit-bindgen-gen-host-js = { path = 'crates/gen-host-js', features = ['structopt'
 wit-bindgen-gen-guest-c = { path = 'crates/gen-guest-c', features = ['structopt'] }
 wit-bindgen-gen-markdown = { path = 'crates/gen-markdown', features = ['structopt'] }
 wit-bindgen-gen-guest-teavm-java = { path = 'crates/gen-guest-teavm-java', features = ['structopt'] }
+
+[patch.crates-io]
+wasmparser = { path = '../wasm-tools/crates/wasmparser' }
+wasm-encoder = { path = '../wasm-tools/crates/wasm-encoder' }

Cargo.toml

@@ -30,6 +30,7 @@ filetime = "0.2"
 wit-bindgen-gen-guest-c = { path = '../gen-guest-c' }
 wit-bindgen-gen-guest-teavm-java = { path = '../gen-guest-teavm-java' }
 wit-bindgen-core = { path = '../bindgen-core' }
+wit-component = { path = '../wit-component' }
 
 [features]
 default = ['guest-rust', 'guest-c', 'guest-teavm-java', 'host-js', 'host-wasmtime-py', 'host-wasmtime-rust']

crates/test-helpers/Cargo.toml

@@ -61,14 +61,16 @@ fn main() {
 
             let import = Interface::parse_file(&test_dir.join("imports.wit")).unwrap();
             let export = Interface::parse_file(&test_dir.join("exports.wit")).unwrap();
+            let imports = &[import];
+            let exports = &[export];
             let mut files = Default::default();
             // TODO: should combine this into one
             wit_bindgen_gen_guest_c::Opts::default()
                 .build()
-                .generate_all(&[import], &[], &mut files);
+                .generate_all(imports, &[], &mut files);
             wit_bindgen_gen_guest_c::Opts::default()
                 .build()
-                .generate_all(&[], &[export], &mut files);
+                .generate_all(&[], exports, &mut files);
 
             let out_dir = out_dir.join(format!(
                 "c-{}",
@@ -120,6 +122,16 @@ fn main() {
                 test_dir.file_stem().unwrap().to_str().unwrap().to_string(),
                 out_wasm.to_str().unwrap().to_string(),
             ));
+
+            let wasm = std::fs::read(&out_wasm).unwrap();
+            wit_component::ComponentEncoder::default()
+                .validate(true)
+                .module(&wasm)
+                .imports(imports)
+                .interface(&exports[0])
+                .wasi(true)
+                .encode()
+                .unwrap();
         }
     }
 

crates/test-helpers/build.rs

@@ -31,10 +31,13 @@ env_logger = { version = "0.9.1", optional = true }
 log = { version = "0.4.17", optional = true }
 bitflags = "1.3.2"
 
+wasmprinter = "*"
+
 [dev-dependencies]
 wasmprinter = "0.2.40"
 glob = "0.3.0"
 pretty_assertions = "1.3.0"
+env_logger = "0.9.1"
 
 [features]
 default = ["cli"]

crates/wit-component/Cargo.toml

@@ -0,0 +1,19 @@
+use crate::validation::ValidatedAdapter;
+use anyhow::{Context, Result};
+use indexmap::IndexMap;
+use wasmparser::FuncType;
+use wit_parser::Interface;
+
+mod gc;
+
+pub fn adapt<'a>(
+    wasm: &[u8],
+    interface: &'a Interface,
+    required: &IndexMap<&str, FuncType>,
+) -> Result<(Vec<u8>, ValidatedAdapter<'a>)> {
+    let wasm = gc::run(wasm, required)
+        .context("failed to reduce input adapter module to its minimal size")?;
+    let info = crate::validation::validate_adapter_module(&wasm, interface, required)
+        .context("failed to validate the imports of the minimized adapter module")?;
+    Ok((wasm, info))
+}