js: Take a component as input, not interfaces (#373)

* js: Take a component as input, not interfaces

This commit is the implementation of #314 for the JS host generator.
The commit here covers basically everything in that issue for JS except
it generates a slightly different structure of the JS output. Otherwise
the main highlights are:

* The JS host generator no longer implements the core `Generator` trait
  since it doesn't really fit in the component-as-input world. For now I
  created an `InterfaceGenerator` trait since similar functionality is
  used just not precisely the same. I expect that this will get iterated
  on over time as worlds and other host generators take shape.

* The `wasmtime-environ` crate from Wasmtime itself, typically a "private"
  dependency of Wasmtime, is used to parse the input component and
  generate an `instantiate` function in JS. Wasmtime does all the heavy
  lifting of creating a linear list of initializers for the component
  and this empowers the generator to simply generate JS that is the list
  of initializers.

* The `wit-component` crate is used to "extract" the `Interface`
  descriptions from the input component. This is used to generate type
  information for TypeScript as well as types for lifting/lowering.
  Internally a correlation is done from a lowering/lifting to an
  `Interface` function to connect the dots when instantiating a component.

Lots of pieces needed updating here such as the runtime tests, the
`wit-bindgen` CLI tool, and the demo web page. These are all updated for
the new structure of the JS host generator.

Overall this surprisingly went much more smoothly than I expected. With
`wit-bindgen` being able to extract `Interface` representations from a
component most of the prior JS host code generation was able to be
reused. Along the way I also felt that the addition of "worlds" would
have relatively obvious insertion points and would be relatively easily
handled in all the places.

The demo and runtime tests are proof enough to me at least that this all
works internally, and this feels like a solid foundation to iterate from
with the addition of worlds and continued support for JS hosts.

* Rebase and fix tests

* Pull in latest `wasmtime` where `main` now works
* Add a `testwasi` implementation for JS and use it in all tests
* Add a dummy `printf` to a C test to ensure it imports `testwasi` like
  the other languages.
* Add a `fd_fdstat_get` stub to make C happy
* Update `fd_write` to only work for fd 1

* Review comments

Author: alexcrichton

Cargo.lock

@@ -28,6 +28,7 @@ env_logger = "0.9.1"
 
 wasmtime = { git = "https://github.com/bytecodealliance/wasmtime", branch = "main" , features = ["component-model"] }
 wasmtime-wasi = { git = "https://github.com/bytecodealliance/wasmtime", branch = "main" }
+wasmtime-environ = { git = "https://github.com/bytecodealliance/wasmtime", branch = "main" }
 wasmprinter = "0.2.41"
 wasmparser = "0.92.0"
 wasm-encoder = "0.18.0"
@@ -62,3 +63,4 @@ wit-bindgen-gen-host-js = { path = 'crates/gen-host-js', features = ['clap'] }
 wit-bindgen-gen-guest-c = { path = 'crates/gen-guest-c', features = ['clap'] }
 wit-bindgen-gen-markdown = { path = 'crates/gen-markdown', features = ['clap'] }
 wit-bindgen-gen-guest-teavm-java = { path = 'crates/gen-guest-teavm-java', features = ['clap'] }
+wat = { workspace = true }

Cargo.toml

@@ -397,7 +397,11 @@ impl Source {
                 self.indent += 1;
             }
             if trimmed.starts_with('}') {
-                self.indent -= 1;
+                // Note that a `saturating_sub` is used here to prevent a panic
+                // here in the case of invalid code being generated in debug
+                // mode. It's typically easier to debug those issues through
+                // looking at the source code rather than getting a panic.
+                self.indent = self.indent.saturating_sub(1);
             }
             if i != lines.len() - 1 || src.ends_with("\n") {
                 self.newline();
@@ -526,3 +530,50 @@ mod tests {
         fn _assert(_: &dyn Generator) {}
     }
 }
+
+/// This is a possible replacement for the `Generator` trait above, currently
+/// only used by the JS bindings for generating bindings for a component.
+///
+/// The current plan is to see how things shake out with worlds and various
+/// other generators to see if everything can be updated to a less
+/// per-`*.wit`-file centric interface in the future. Even this will probably
+/// change for JS though. In any case it's something that was useful for JS and
+/// is suitable to replace otherwise at any time.
+pub trait InterfaceGenerator<'a> {
+    fn iface(&self) -> &'a Interface;
+
+    fn type_record(&mut self, id: TypeId, name: &str, record: &Record, docs: &Docs);
+    fn type_flags(&mut self, id: TypeId, name: &str, flags: &Flags, docs: &Docs);
+    fn type_tuple(&mut self, id: TypeId, name: &str, flags: &Tuple, docs: &Docs);
+    fn type_variant(&mut self, id: TypeId, name: &str, variant: &Variant, docs: &Docs);
+    fn type_option(&mut self, id: TypeId, name: &str, payload: &Type, docs: &Docs);
+    fn type_result(&mut self, id: TypeId, name: &str, result: &Result_, docs: &Docs);
+    fn type_union(&mut self, id: TypeId, name: &str, union: &Union, docs: &Docs);
+    fn type_enum(&mut self, id: TypeId, name: &str, enum_: &Enum, docs: &Docs);
+    fn type_alias(&mut self, id: TypeId, name: &str, ty: &Type, docs: &Docs);
+    fn type_list(&mut self, id: TypeId, name: &str, ty: &Type, docs: &Docs);
+    fn type_builtin(&mut self, id: TypeId, name: &str, ty: &Type, docs: &Docs);
+
+    fn types(&mut self) {
+        for (id, ty) in self.iface().types.iter() {
+            let name = match &ty.name {
+                Some(name) => name,
+                None => continue,
+            };
+            match &ty.kind {
+                TypeDefKind::Record(record) => self.type_record(id, name, record, &ty.docs),
+                TypeDefKind::Flags(flags) => self.type_flags(id, name, flags, &ty.docs),
+                TypeDefKind::Tuple(tuple) => self.type_tuple(id, name, tuple, &ty.docs),
+                TypeDefKind::Enum(enum_) => self.type_enum(id, name, enum_, &ty.docs),
+                TypeDefKind::Variant(variant) => self.type_variant(id, name, variant, &ty.docs),
+                TypeDefKind::Option(t) => self.type_option(id, name, t, &ty.docs),
+                TypeDefKind::Result(r) => self.type_result(id, name, r, &ty.docs),
+                TypeDefKind::Union(u) => self.type_union(id, name, u, &ty.docs),
+                TypeDefKind::List(t) => self.type_list(id, name, t, &ty.docs),
+                TypeDefKind::Type(t) => self.type_alias(id, name, t, &ty.docs),
+                TypeDefKind::Future(_) => todo!("generate for future"),
+                TypeDefKind::Stream(_) => todo!("generate for stream"),
+            }
+        }
+    }
+}