Remove FunctionType (#2510)

Function signatures were previously redundantly stored on Function
objects as well as on FunctionType objects. These two signature
representations had to always be kept in sync, which was error-prone
and needlessly complex. This PR takes advantage of the new ability of
Type to represent multiple value types by consolidating function
signatures as a pair of Types (params and results) stored on the
Function object.

Since there are no longer module-global named function types,
significant changes had to be made to the printing and emitting of
function types, as well as their parsing and manipulation in various
passes.

The C and JS APIs and their tests also had to be updated to remove
named function types.

1 files changed, 8 insertions, 52 deletions

diff --git a/src/asmjs/asm_v_wasm.cpp b/src/asmjs/asm_v_wasm.cpp
index 2fba0520a..3720ca079 100644
--- a/src/asmjs/asm_v_wasm.cpp
+++ b/src/asmjs/asm_v_wasm.cpp
@@ -89,62 +89,18 @@ char getSig(Type type) {
   WASM_UNREACHABLE("invalid type");
 }
 
-std::string getSig(const FunctionType* type) {
-  return getSig(type->params, type->result);
-}
-
 std::string getSig(Function* func) {
-  return getSig(func->params, func->result);
-}
-
-Type sigToType(char sig) {
-  switch (sig) {
-    case 'i':
-      return i32;
-    case 'j':
-      return i64;
-    case 'f':
-      return f32;
-    case 'd':
-      return f64;
-    case 'V':
-      return v128;
-    case 'a':
-      return anyref;
-    case 'e':
-      return exnref;
-    case 'v':
-      return none;
-    default:
-      abort();
-  }
+  return getSig(func->sig.results, func->sig.params);
 }
 
-FunctionType sigToFunctionType(const std::string& sig) {
-  FunctionType ret;
-  ret.result = sigToType(sig[0]);
-  for (size_t i = 1; i < sig.size(); i++) {
-    ret.params.push_back(sigToType(sig[i]));
-  }
-  return ret;
-}
-
-FunctionType*
-ensureFunctionType(const std::string& sig, Module* wasm, Name name) {
-  if (!name.is()) {
-    name = "FUNCSIG$" + sig;
-  }
-  if (wasm->getFunctionTypeOrNull(name)) {
-    return wasm->getFunctionType(name);
-  }
-  // add new type
-  auto type = make_unique<FunctionType>();
-  type->name = name;
-  type->result = sigToType(sig[0]);
-  for (size_t i = 1; i < sig.size(); i++) {
-    type->params.push_back(sigToType(sig[i]));
+std::string getSig(Type results, Type params) {
+  assert(!results.isMulti());
+  std::string sig;
+  sig += getSig(results);
+  for (Type t : params.expand()) {
+    sig += getSig(t);
   }
-  return wasm->addFunctionType(std::move(type));
+  return sig;
 }
 
 Expression* ensureDouble(Expression* expr, MixedArena& allocator) {