Propagate module-linking types to wasmtime (#2115)

This commit adds lots of plumbing to get the type section from the
module linking proposal plumbed all the way through to the `wasmtime`
crate and the `wasmtime-c-api` crate. This isn't all that useful right
now because Wasmtime doesn't support imported/exported
modules/instances, but this is all necessary groundwork to getting that
exported at some point. I've added some light tests but I suspect the
bulk of the testing will come in a future commit.

One major change in this commit is that `SignatureIndex` no longer
follows type type index space in a wasm module. Instead a new
`TypeIndex` type is used to track that. Function signatures, still
indexed by `SignatureIndex`, are then packed together tightly.

cranelift/wasm/src/environ/spec.rs

@@ -8,8 +8,8 @@
 
 use crate::state::FuncTranslationState;
 use crate::translation_utils::{
-    DataIndex, ElemIndex, FuncIndex, Global, GlobalIndex, Memory, MemoryIndex, SignatureIndex,
-    Table, TableIndex,
+    DataIndex, ElemIndex, EntityType, FuncIndex, Global, GlobalIndex, Memory, MemoryIndex, Table,
+    TableIndex, TypeIndex,
 };
 use core::convert::From;
 use core::convert::TryFrom;
@@ -293,7 +293,7 @@ pub trait FuncEnvironment: TargetEnvironment {
     fn make_indirect_sig(
         &mut self,
         func: &mut ir::Function,
-        index: SignatureIndex,
+        index: TypeIndex,
     ) -> WasmResult<ir::SigRef>;
 
     /// Set up an external function definition in the preamble of `func` that can be used to
@@ -328,7 +328,7 @@ pub trait FuncEnvironment: TargetEnvironment {
         pos: FuncCursor,
         table_index: TableIndex,
         table: ir::Table,
-        sig_index: SignatureIndex,
+        sig_index: TypeIndex,
         sig_ref: ir::SigRef,
         callee: ir::Value,
         call_args: &[ir::Value],
@@ -630,19 +630,35 @@ pub trait FuncEnvironment: TargetEnvironment {
 /// [`translate_module`](fn.translate_module.html) function. These methods should not be called
 /// by the user, they are only for `cranelift-wasm` internal use.
 pub trait ModuleEnvironment<'data>: TargetEnvironment {
-    /// Provides the number of signatures up front. By default this does nothing, but
+    /// Provides the number of types up front. By default this does nothing, but
     /// implementations can use this to preallocate memory if desired.
-    fn reserve_signatures(&mut self, _num: u32) -> WasmResult<()> {
+    fn reserve_types(&mut self, _num: u32) -> WasmResult<()> {
         Ok(())
     }
 
     /// Declares a function signature to the environment.
-    fn declare_signature(
+    fn declare_type_func(
         &mut self,
         wasm_func_type: WasmFuncType,
         sig: ir::Signature,
     ) -> WasmResult<()>;
 
+    /// Declares a module type signature to the environment.
+    fn declare_type_module(
+        &mut self,
+        imports: &[(&'data str, Option<&'data str>, EntityType)],
+        exports: &[(&'data str, EntityType)],
+    ) -> WasmResult<()> {
+        drop((imports, exports));
+        Err(WasmError::Unsupported("module linking".to_string()))
+    }
+
+    /// Declares an instance type signature to the environment.
+    fn declare_type_instance(&mut self, exports: &[(&'data str, EntityType)]) -> WasmResult<()> {
+        drop(exports);
+        Err(WasmError::Unsupported("module linking".to_string()))
+    }
+
     /// Provides the number of imports up front. By default this does nothing, but
     /// implementations can use this to preallocate memory if desired.
     fn reserve_imports(&mut self, _num: u32) -> WasmResult<()> {
@@ -652,7 +668,7 @@ pub trait ModuleEnvironment<'data>: TargetEnvironment {
     /// Declares a function import to the environment.
     fn declare_func_import(
         &mut self,
-        sig_index: SignatureIndex,
+        index: TypeIndex,
         module: &'data str,
         field: &'data str,
     ) -> WasmResult<()>;
@@ -681,6 +697,28 @@ pub trait ModuleEnvironment<'data>: TargetEnvironment {
         field: &'data str,
     ) -> WasmResult<()>;
 
+    /// Declares a module import to the environment.
+    fn declare_module_import(
+        &mut self,
+        ty_index: TypeIndex,
+        module: &'data str,
+        field: &'data str,
+    ) -> WasmResult<()> {
+        drop((ty_index, module, field));
+        Err(WasmError::Unsupported("module linking".to_string()))
+    }
+
+    /// Declares an instance import to the environment.
+    fn declare_instance_import(
+        &mut self,
+        ty_index: TypeIndex,
+        module: &'data str,
+        field: &'data str,
+    ) -> WasmResult<()> {
+        drop((ty_index, module, field));
+        Err(WasmError::Unsupported("module linking".to_string()))
+    }
+
     /// Notifies the implementation that all imports have been declared.
     fn finish_imports(&mut self) -> WasmResult<()> {
         Ok(())
@@ -693,7 +731,7 @@ pub trait ModuleEnvironment<'data>: TargetEnvironment {
     }
 
     /// Declares the type (signature) of a local function in the module.
-    fn declare_func_type(&mut self, sig_index: SignatureIndex) -> WasmResult<()>;
+    fn declare_func_type(&mut self, index: TypeIndex) -> WasmResult<()>;
 
     /// Provides the number of defined tables up front. By default this does nothing, but
     /// implementations can use this to preallocate memory if desired.