call_indirect is now structural in spec:314

src/wasm-interpreter.h

@@ -670,7 +670,6 @@ class ModuleInstance {
         if (index >= instance.wasm.table.names.size()) trap("callIndirect: overflow");
         Name name = instance.wasm.table.names[index];
         Function *func = instance.wasm.getFunction(name);
-        if (func->type.is() && func->type != curr->fullType) trap("callIndirect: bad type");
         if (func->params.size() != arguments.size()) trap("callIndirect: bad # of arguments");
         for (size_t i = 0; i < func->params.size(); i++) {
           if (func->params[i] != arguments[i].type) {

src/wasm-s-parser.h

@@ -312,21 +312,49 @@ class SExpressionWasmBuilder {
     }
     functionNames.push_back(name);
     functionCounter++;
+    FunctionType* type = nullptr;
+    functionTypes[name] = none;
+    std::vector<WasmType> params;
     for (;i < s.size(); i++) {
       Element& curr = *s[i];
       IString id = curr[0]->str();
       if (id == RESULT) {
         functionTypes[name] = stringToWasmType(curr[1]->str());
-        return;
       } else if (id == TYPE) {
         Name typeName = curr[1]->str();
         if (!wasm.checkFunctionType(typeName)) throw ParseException("unknown function");
-        FunctionType* type = wasm.getFunctionType(typeName);
+        type = wasm.getFunctionType(typeName);
         functionTypes[name] = type->result;
-        return;
+      } else if (id == PARAM && curr.size() > 1) {
+        Index j = 1;
+        if (curr[j]->dollared()) {
+          // dollared input symbols cannot be types
+          params.push_back(stringToWasmType(curr[j + 1]->str(), true));
+        } else {
+          while (j < curr.size()) {
+            params.push_back(stringToWasmType(curr[j++]->str(), true));
+          }
+        }
+      }
+    }
+    if (!type) {
+      // if no function type provided, generate one, but reuse a previous one with the
+      // right structure if there is
+      // see https://github.com/WebAssembly/spec/pull/301
+      bool need = true;
+      std::unique_ptr<FunctionType> functionType = make_unique<FunctionType>();
+      functionType->result = functionTypes[name];
+      functionType->params = std::move(params);
+      for (auto& existing : wasm.functionTypes) {
+        if (existing->structuralComparison(*functionType)) {
+          need = false;
+          break;
+        }
+      }
+      if (need) {
+        wasm.addFunctionType(functionType.release());
       }
     }
-    functionTypes[name] = none;
   }
 
   void preParseImports(Element& curr) {
@@ -500,16 +528,21 @@ class SExpressionWasmBuilder {
       body = allocator.alloc<Nop>();
     }
     if (currFunction->result != result) throw ParseException("bad func declaration", s.line, s.col);
-    /* TODO: spec in flux, https://github.com/WebAssembly/spec/pull/301
+    // see https://github.com/WebAssembly/spec/pull/301
     if (type.isNull()) {
-      // if no function type provided, generate a private one for this function
+      // if no function type name provided, then we generated one
       auto* functionType = sigToFunctionType(getSig(currFunction.get()));
-      wasm.addFunctionType(functionType);
-      type = functionType->name;
+      for (auto& existing : wasm.functionTypes) {
+        if (existing->structuralComparison(*functionType)) {
+          type = existing->name;
+          break;
+        }
+      }
+      assert(type.is());
     }
-    */
     currFunction->body = body;
     currFunction->type = type;
+
     wasm.addFunction(currFunction.release());
     currLocalTypes.clear();
     labelStack.clear();

src/wasm.h

@@ -1065,15 +1065,19 @@ class FunctionType {
 
   FunctionType() : result(none) {}
 
-  bool operator==(FunctionType& b) {
-    if (name != b.name) return false; // XXX
+  bool structuralComparison(FunctionType& b) {
     if (result != b.result) return false;
     if (params.size() != b.params.size()) return false;
     for (size_t i = 0; i < params.size(); i++) {
       if (params[i] != b.params[i]) return false;
     }
     return true;
   }
+
+  bool operator==(FunctionType& b) {
+    if (name != b.name) return false;
+    return structuralComparison(b);
+  }
   bool operator!=(FunctionType& b) {
     return !(*this == b);
   }