wasm-merge: Handle imported functions that use supertypes (#7957)

In such a case we must update (refine) the type after merging, to avoid
validation errors.

Author: kripken

src/tools/wasm-merge.cpp

@@ -99,6 +99,7 @@
 
 #include "ir/module-utils.h"
 #include "ir/names.h"
+#include "ir/utils.h"
 #include "support/colors.h"
 #include "support/file.h"
 #include "wasm-builder.h"
@@ -557,6 +558,30 @@ void fuseImportsAndExports(const PassOptions& options) {
   updateNames(merged, kindNameUpdates);
 }
 
+// Things may have been imported using supertypes, which means they can get
+// refined after merging.
+void updateTypes(Module& wasm) {
+  struct Updater : public WalkerPass<PostWalker<Updater>> {
+    bool isFunctionParallel() override { return true; }
+
+    std::unique_ptr<Pass> create() override {
+      return std::make_unique<Updater>();
+    }
+
+    void visitRefFunc(RefFunc* curr) {
+      curr->finalize(getModule()->getFunction(curr->func)->type);
+    }
+
+    void visitFunction(Function* curr) {
+      ReFinalize().walkFunctionInModule(curr, getModule());
+    }
+  } updater;
+
+  PassRunner runner(&wasm);
+  updater.run(&runner, &wasm);
+  updater.runOnModuleCode(&runner, &wasm);
+}
+
 // Merges an input module into an existing target module. The input module can
 // be modified, as it will no longer be needed (so it is intentionally not
 // marked as const here).
@@ -765,6 +790,9 @@ Input source maps can be specified by adding an -ism option right after the modu
   // module.
   fuseImportsAndExports(options.passOptions);
 
+  // Update types after combing and linking everything.
+  updateTypes(merged);
+
   {
     PassRunner passRunner(&merged);
     // We might have made some globals read from others that now appear after

test/lit/merge/func_subtyping.wat

@@ -0,0 +1,32 @@
+;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited.
+
+;; RUN: wasm-merge %s primary %s.second secondary --skip-export-conflicts -all -S -o - | filecheck %s
+
+;; Export a function with a subtype. It is imported using the supertype, and
+;; after we merge, the type must be updated. That update will then propagate to
+;; the call_ref.
+(module
+ ;; CHECK:      (type $super (sub (func)))
+ (type $super (sub (func)))
+ ;; CHECK:      (type $sub (sub final $super (func)))
+ (type $sub (sub final $super (func)))
+
+ ;; CHECK:      (type $2 (func))
+
+ ;; CHECK:      (elem declare func $sub)
+
+ ;; CHECK:      (export "sub" (func $sub))
+
+ ;; CHECK:      (export "caller" (func $caller))
+
+ ;; CHECK:      (func $sub (type $sub)
+ ;; CHECK-NEXT: )
+ (func $sub (export "sub") (type $sub)
+ )
+)
+
+;; CHECK:      (func $caller (type $2)
+;; CHECK-NEXT:  (call_ref $sub
+;; CHECK-NEXT:   (ref.func $sub)
+;; CHECK-NEXT:  )
+;; CHECK-NEXT: )

test/lit/merge/func_subtyping.wat.second

@@ -0,0 +1,12 @@
+(module
+ (type $second-super (sub (func)))
+
+ (import "primary" "sub" (func $import (type $second-super)))
+
+ (func $caller (export "caller")
+  (call_ref $second-super
+   (ref.func $import)
+  )
+ )
+)
+