Fix ctor-eval when the same name is imported twice

src/tools/wasm-ctor-eval.cpp

@@ -140,20 +140,20 @@ std::vector<std::unique_ptr<Module>> buildStubModules(Module& wasm) {
       Module* module = it->second.get();
 
       struct Visitor {
-        Module* module;
+        Module* module = nullptr;
+
         void operator()(Memory* memory) {
           auto* copied = ModuleUtils::copyMemory(memory, *module);
           copied->module = Name();
           copied->base = Name();
-          module->addExport(Builder(*module).makeExport(
+          module->maybeAddExport(Builder::makeExport(
             memory->base, copied->name, ExternalKind::Memory));
         }
         void operator()(Table* table) {
-          // create tables with similar initial and max values
           auto* copied = ModuleUtils::copyTable(table, *module);
           copied->module = Name();
           copied->base = Name();
-          module->addExport(Builder(*module).makeExport(
+          module->maybeAddExport(Builder::makeExport(
             table->base, copied->name, ExternalKind::Table));
         }
         void operator()(Global* global) {
@@ -163,17 +163,14 @@ std::vector<std::unique_ptr<Module>> buildStubModules(Module& wasm) {
 
           Builder builder(*module);
           copied->init = builder.makeConst(Literal::makeZero(global->type));
-          module->addExport(builder.makeExport(
+          module->maybeAddExport(Builder::makeExport(
             global->base, copied->name, ExternalKind::Global));
         }
         void operator()(Function* func) {
           Builder builder(*module);
-          auto* copied = ModuleUtils::copyFunction(func, *module);
-          copied->module = Name();
-          copied->base = Name();
-          copied->body = builder.makeUnreachable();
-          module->addExport(builder.makeExport(
-            func->base, copied->name, ExternalKind::Function));
+          auto stubbedFunc = builder.makeUnreachableFunction(func->name);
+          module->maybeAddExport(Builder::makeExport(
+            func->base, stubbedFunc->name, ExternalKind::Function));
         }
         void operator()(Tag* tag) {
           // no-op

src/wasm-builder.h

@@ -43,11 +43,19 @@ class Builder {
 
   // make* functions create an expression instance.
 
+  std::unique_ptr<Function> makeUnreachableFunction(Name name) {
+    auto func = std::make_unique<Function>();
+    func->name = name;
+    func->type = Type::unreachable;
+    func->body = makeUnreachable();
+    return func;
+  }
+
   static std::unique_ptr<Function> makeFunction(Name name,
                                                 Type type,
                                                 std::vector<Type>&& vars,
                                                 Expression* body = nullptr) {
-    assert(type.isSignature() && type.isNonNullable());
+    // assert(type.isSignature() && type.isNonNullable());
     auto func = std::make_unique<Function>();
     func->name = name;
     func->type = type;

src/wasm.h

@@ -2596,6 +2596,7 @@ class Module {
   Tag* addTag(Tag* curr);
 
   Export* addExport(std::unique_ptr<Export>&& curr);
+  Export* maybeAddExport(std::unique_ptr<Export>&& curr);
   Function* addFunction(std::unique_ptr<Function>&& curr);
   Table* addTable(std::unique_ptr<Table>&& curr);
   ElementSegment* addElementSegment(std::unique_ptr<ElementSegment>&& curr);

src/wasm/wasm.cpp

@@ -1829,6 +1829,22 @@ Elem* addModuleElement(Vector& v,
   return ret;
 }
 
+template<typename Vector, typename Map, typename Elem>
+Elem* maybeAddModuleElement(Vector& v,
+                            Map& m,
+                            std::unique_ptr<Elem> curr,
+                            std::string funcName) {
+  if (!curr->name.is()) {
+    Fatal() << "Module::" << funcName << ": empty name";
+  }
+  if (getModuleElementOrNull(m, curr->name)) {
+    return nullptr;
+  }
+  auto* ret = m[curr->name] = curr.get();
+  v.push_back(std::move(curr));
+  return ret;
+}
+
 Export* Module::addExport(Export* curr) {
   return addModuleElement(exports, exportsMap, curr, "addExport");
 }
@@ -1849,6 +1865,11 @@ Export* Module::addExport(std::unique_ptr<Export>&& curr) {
   return addModuleElement(exports, exportsMap, std::move(curr), "addExport");
 }
 
+Export* Module::maybeAddExport(std::unique_ptr<Export>&& curr) {
+  return maybeAddModuleElement(
+    exports, exportsMap, std::move(curr), "addExport");
+}
+
 Function* Module::addFunction(std::unique_ptr<Function>&& curr) {
   return addModuleElement(
     functions, functionsMap, std::move(curr), "addFunction");

test/ctor-eval/repeated-import.wast

@@ -0,0 +1,9 @@
+(module
+ (import "import" "log" (func $logi32 (param i32)))
+ (import "import" "log" (func $logi64 (param i64)))
+ (export "foo" (func $0))
+ (func $0 (param $0 i32)
+   (local.get $0)
+   (call $logi32)
+ )
+)

test/ctor-eval/repeated-import.wast.ctors

@@ -0,0 +1 @@
+foo

test/ctor-eval/repeated-import.wast.out

@@ -0,0 +1,10 @@
+(module
+ (type $0 (func (param i32)))
+ (import "import" "log" (func $logi32 (type $0) (param i32)))
+ (export "foo" (func $0))
+ (func $0 (type $0) (param $0 i32)
+  (call $logi32
+   (local.get $0)
+  )
+ )
+)