Handle same-named imports with different signatures

This commit fixes the `wasmtime::Instance` instantiation API when
imports have the same name but might be imported under different types.
This is handled in the API by listing imports as a list instead of as a
name map, but they were interpreted as a name map under the hood causing
collisions.

This commit now keeps track of the index used to define each import, and
the index is passed through in the `Resolver`. Existing implementaitons
of `Resolver` all ignore this, but the API now uses it exclusivley to
match up `Extern` definitions to imports.

crates/jit/src/link.rs

@@ -30,8 +30,8 @@ pub fn link_module(
     let mut dependencies = HashSet::new();
 
     let mut function_imports = PrimaryMap::with_capacity(module.imported_funcs.len());
-    for (index, (ref module_name, ref field)) in module.imported_funcs.iter() {
-        match resolver.resolve(module_name, field) {
+    for (index, (module_name, field, import_idx)) in module.imported_funcs.iter() {
+        match resolver.resolve(*import_idx, module_name, field) {
             Some(export_value) => match export_value {
                 Export::Function {
                     address,
@@ -71,8 +71,8 @@ pub fn link_module(
     }
 
     let mut table_imports = PrimaryMap::with_capacity(module.imported_tables.len());
-    for (index, (ref module_name, ref field)) in module.imported_tables.iter() {
-        match resolver.resolve(module_name, field) {
+    for (index, (module_name, field, import_idx)) in module.imported_tables.iter() {
+        match resolver.resolve(*import_idx, module_name, field) {
             Some(export_value) => match export_value {
                 Export::Table {
                     definition,
@@ -110,8 +110,8 @@ pub fn link_module(
     }
 
     let mut memory_imports = PrimaryMap::with_capacity(module.imported_memories.len());
-    for (index, (ref module_name, ref field)) in module.imported_memories.iter() {
-        match resolver.resolve(module_name, field) {
+    for (index, (module_name, field, import_idx)) in module.imported_memories.iter() {
+        match resolver.resolve(*import_idx, module_name, field) {
             Some(export_value) => match export_value {
                 Export::Memory {
                     definition,
@@ -163,8 +163,8 @@ pub fn link_module(
     }
 
     let mut global_imports = PrimaryMap::with_capacity(module.imported_globals.len());
-    for (index, (ref module_name, ref field)) in module.imported_globals.iter() {
-        match resolver.resolve(module_name, field) {
+    for (index, (module_name, field, import_idx)) in module.imported_globals.iter() {
+        match resolver.resolve(*import_idx, module_name, field) {
             Some(export_value) => match export_value {
                 Export::Table { .. } | Export::Memory { .. } | Export::Function { .. } => {
                     return Err(LinkError(format!(

crates/jit/src/namespace.rs

@@ -36,7 +36,7 @@ impl Namespace {
 }
 
 impl Resolver for Namespace {
-    fn resolve(&mut self, name: &str, field: &str) -> Option<Export> {
+    fn resolve(&mut self, _idx: u32, name: &str, field: &str) -> Option<Export> {
         if let Some(instance) = self.names.get_mut(name) {
             instance.lookup(field)
         } else {

crates/jit/src/resolver.rs

@@ -5,15 +5,22 @@ use wasmtime_runtime::Export;
 
 /// Import resolver connects imports with available exported values.
 pub trait Resolver {
-    /// Resolve the given module/field combo.
-    fn resolve(&mut self, module: &str, field: &str) -> Option<Export>;
+    /// Resolves an import a WebAssembly module to an export it's hooked up to.
+    ///
+    /// The `index` provided is the index of the import in the wasm module
+    /// that's being resolved. For example 1 means that it's the second import
+    /// listed in the wasm module.
+    ///
+    /// The `module` and `field` arguments provided are the module/field names
+    /// listed on the import itself.
+    fn resolve(&mut self, index: u32, module: &str, field: &str) -> Option<Export>;
 }
 
 /// `Resolver` implementation that always resolves to `None`.
 pub struct NullResolver {}
 
 impl Resolver for NullResolver {
-    fn resolve(&mut self, _module: &str, _field: &str) -> Option<Export> {
+    fn resolve(&mut self, _idx: u32, _module: &str, _field: &str) -> Option<Export> {
         None
     }
 }