compiler: ResolveImportedFunction should infer the typeID from the importing module

[evacchi]

Fixes #2313.

This changes the signature for ResolveImportedFunction() so that it takes an additional index into the typeID section of the "current" module, i.e. the subject of the import.

The current behavior is to search for the import recursively into the chain of dependencies; however, this resolves to a typeID that is specific to that module. For instance:

• consider the case of a module m declaring an import m2inst.sym.
• let be m2inst.sym an import with type t with ID tid
• let be m2inst be linked to an instance of module m2 with type t2 and ID t2id.

Now: we want t to be compatible with t2; this we verify at:

wazero/internal/wasm/store.go

Lines 441 to 447 in 6bb9899

	expectedType := &module.TypeSection[i.DescFunc]
	src := importedModule.Source
	actual := src.typeOfFunction(imported.Index)
	if !actual.EqualsSignature(expectedType.Params, expectedType.Results) {
	err = errorInvalidImport(i, fmt.Errorf("signature mismatch: %s != %s", expectedType, actual))
	return
	}

The current behavior is for ResolveImportedFunction() to resolve recursively a reference to a function so that we can then jump precisely to its address at runtime; however, we should not carry on its type ID, and instead use the type ID of the import.

In other words, even if the types are compatible, we should be still referring to type t with ID tid from m, and not type ID t2id, because, of course, the index t2id might be different from the local index tid.

The solution is to add another descFunc Index (from the name of the field Import.DescFunc) to the signature of ResolveImportedFunction(), so that the typeID is correctly resolved from moduleEngine.module.TypeIDs[descFunc] (i.e. the typeID defined in the module that is requiring the imported function).

The tests are adjusted accordingly; notably, this also means that, in order for m.ResolveImportedFunction() to work properly, m must be correctly initialized with an m.module being the module that is performing the import, so the initialization of moduleEngine is pushed down, after the declaration of the "imported" and "importing" modules.

Let me know if you think it is worth adding more tests!

@zshipko please double-check that this is fixing your issue (I have slightly changed my original approach)
@ncruces would you like to double-check this against your sqlite lib?
@anuraaga if you spare any time, would you take a look too? :P

[zshipko]

Just tested this and verified it fixes the issue on my end! 🥳

Thank you!

[ncruces]

Everything seems to work fine.