Add support for nested components (#4285)

* Add support for nested components

This commit is an implementation of a number of features of the
component model including:

* Defining nested components
* Outer aliases to components and modules
* Instantiating nested components

The implementation here is intended to be a foundational pillar of
Wasmtime's component model support since recursion and nested components
are the bread-and-butter of the component model. At a high level the
intention for the component model implementation in Wasmtime has long
been that the recursive nature of components is "erased" at compile time
to something that's more optimized and efficient to process. This commit
ended up exemplifying this quite well where the vast majority of the
internal changes here are in the "compilation" phase of a component
rather than the runtime instantiation phase. The support in the
`wasmtime` crate, the runtime instantiation support, only had minor
updates here while the internals of translation have seen heavy updates.

The `translate` module was greatly refactored here in this commit.
Previously it would, as a component is parsed, create a final
`Component` to hand off to trampoline compilation and get persisted at
runtime. Instead now it's a thin layer over `wasmparser` which simply
records a list of `LocalInitializer` entries for how to instantiate the
component and its index spaces are built. This internal representation
of the instantiation of a component is pretty close to the binary format
intentionally.

Instead of performing dataflow legwork the `translate` phase of a
component is now responsible for two primary tasks:

1. All components and modules are discovered within a component. They're
   assigned `Static{Component,Module}Index` depending on where they're
   found and a `{Module,}Translation` is prepared for each one. This
   "flattens" the recursive structure of the binary into an indexed list
   processable later.

2. The lexical scope of components is managed here to implement outer
   module and component aliases. This is a significant design
   implementation because when closing over an outer component or module
   that item may actually be imported or something like the result of a
   previous instantiation. This means that the capture of
   modules and components is both a lexical concern as well as a runtime
   concern. The handling of the "runtime" bits are handled in the next
   phase of compilation.

The next and currently final phase of compilation is a new pass where
much of the historical code in `translate.rs` has been moved to (but
heavily refactored). The goal of compilation is to produce one "flat"
list of initializers for a component (as happens prior to this PR) and
to achieve this an "inliner" phase runs which runs through the
instantiation process at compile time to produce a list of initializers.
This `inline` module is the main addition as part of this PR and is now
the workhorse for dataflow analysis and tracking what's actually
referring to what.

During the `inline` phase the local initializers recorded in the
`translate` phase are processed, in sequence, to instantiate a
component. Definitions of items are tracked to correspond to their root
definition which allows seeing across instantiation argument boundaries
and such. Handling "upvars" for component outer aliases is handled in
the `inline` phase as well by creating state for a component whenever a
component is defined as was recorded during the `translate` phase.
Finally this phase is chiefly responsible for doing all string-based
name resolution at compile time that it can. This means that at runtime
no string maps will need to be consulted for item exports and such.
The final result of inlining is a list of "global initializers" which is
a flat list processed during instantiation time. These are almost
identical to the initializers that were processed prior to this PR.

There are certainly still more gaps of the component model to implement
but this should be a major leg up in terms of functionality that
Wasmtime implements. This commit, however leaves behind a "hole" which
is not intended to be filled in at this time, namely importing and
exporting components at the "root" level from and to the host. This is
tracked and explained in more detail as part of #4283.

cc #4185 as this completes a number of items there

* Tweak code to work on stable without warning

* Review comments

tests/all/component_model.rs

@@ -4,6 +4,7 @@ use wasmtime::{Config, Engine};
 
 mod func;
 mod import;
+mod nested;
 
 // A simple bump allocator which can be used with modules
 const REALLOC_AND_FREE: &str = r#"

tests/all/component_model/nested.rs

@@ -0,0 +1,172 @@
+use super::REALLOC_AND_FREE;
+use anyhow::Result;
+use wasmtime::component::*;
+use wasmtime::{Module, Store, StoreContextMut};
+
+#[test]
+fn top_level_instance_two_level() -> Result<()> {
+    let component = r#"
+(component
+  (import "c" (instance $i
+    (export "c" (instance
+      (export "m" (core module
+        (export "g" (global i32))
+      ))
+    ))
+  ))
+  (component $c1
+    (import "c" (instance $i
+      (export "c" (instance
+        (export "m" (core module
+          (export "g" (global i32))
+        ))
+      ))
+    ))
+    (core module $verify
+      (import "" "g" (global i32))
+      (func $start
+        global.get 0
+        i32.const 101
+        i32.ne
+        if unreachable end
+      )
+
+      (start $start)
+    )
+    (core instance $m (instantiate (module $i "c" "m")))
+    (core instance (instantiate $verify (with "" (instance $m))))
+  )
+  (instance (instantiate $c1 (with "c" (instance $i))))
+)
+    "#;
+    let module = r#"
+(module
+  (global (export "g") i32 i32.const 101)
+)
+    "#;
+
+    let engine = super::engine();
+    let module = Module::new(&engine, module)?;
+    let component = Component::new(&engine, component)?;
+    let mut store = Store::new(&engine, ());
+    let mut linker = Linker::new(&engine);
+    linker.instance("c")?.instance("c")?.module("m", &module)?;
+    linker.instantiate(&mut store, &component)?;
+    Ok(())
+}
+
+#[test]
+fn nested_many_instantiations() -> Result<()> {
+    let component = r#"
+(component
+  (import "count" (func $count))
+  (component $c1
+    (import "count" (func $count))
+    (core func $count_lower (canon lower (func $count)))
+    (core module $m
+        (import "" "" (func $count))
+        (start $count)
+    )
+    (core instance (instantiate $m (with "" (instance (export "" (func $count_lower))))))
+    (core instance (instantiate $m (with "" (instance (export "" (func $count_lower))))))
+  )
+  (component $c2
+    (import "count" (func $count))
+    (instance (instantiate $c1 (with "count" (func $count))))
+    (instance (instantiate $c1 (with "count" (func $count))))
+  )
+  (component $c3
+    (import "count" (func $count))
+    (instance (instantiate $c2 (with "count" (func $count))))
+    (instance (instantiate $c2 (with "count" (func $count))))
+  )
+  (component $c4
+    (import "count" (func $count))
+    (instance (instantiate $c3 (with "count" (func $count))))
+    (instance (instantiate $c3 (with "count" (func $count))))
+  )
+
+  (instance (instantiate $c4 (with "count" (func $count))))
+)
+    "#;
+    let engine = super::engine();
+    let component = Component::new(&engine, component)?;
+    let mut store = Store::new(&engine, 0);
+    let mut linker = Linker::new(&engine);
+    linker
+        .root()
+        .func_wrap("count", |mut store: StoreContextMut<'_, u32>| {
+            *store.data_mut() += 1;
+            Ok(())
+        })?;
+    linker.instantiate(&mut store, &component)?;
+    assert_eq!(*store.data(), 16);
+    Ok(())
+}
+
+#[test]
+fn thread_options_through_inner() -> Result<()> {
+    let component = format!(
+        r#"
+(component
+  (import "hostfn" (func $host (param u32) (result string)))
+
+  (component $c
+    (import "hostfn" (func $host (param u32) (result string)))
+
+    (core module $libc
+        (memory (export "memory") 1)
+        {REALLOC_AND_FREE}
+    )
+    (core instance $libc (instantiate $libc))
+
+    (core func $host_lower
+        (canon lower
+            (func $host)
+            (memory $libc "memory")
+            (realloc (func $libc "realloc"))
+        )
+    )
+
+    (core module $m
+        (import "" "host" (func $host (param i32 i32)))
+        (import "libc" "memory" (memory 1))
+        (func (export "run") (param i32) (result i32)
+            i32.const 42
+            i32.const 100
+            call $host
+            i32.const 100
+        )
+        (export "memory" (memory 0))
+    )
+    (core instance $m (instantiate $m
+        (with "" (instance (export "host" (func $host_lower))))
+        (with "libc" (instance $libc))
+    ))
+
+    (func (export "run") (param u32) (result string)
+        (canon lift
+            (core func $m "run")
+            (memory $m "memory")
+        )
+    )
+  )
+  (instance $c (instantiate $c (with "hostfn" (func $host))))
+  (export "run" (func $c "run"))
+)
+    "#
+    );
+    let engine = super::engine();
+    let component = Component::new(&engine, component)?;
+    let mut store = Store::new(&engine, 0);
+    let mut linker = Linker::new(&engine);
+    linker
+        .root()
+        .func_wrap("hostfn", |param: u32| Ok(param.to_string()))?;
+    let instance = linker.instantiate(&mut store, &component)?;
+    let result = instance
+        .get_typed_func::<(u32,), WasmStr, _>(&mut store, "run")?
+        .call(&mut store, (43,))?;
+    assert_eq!(result.to_str(&store)?, "42");
+    Ok(())
+}