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, 0 insertions, 56 deletions

diff --git a/src/passes/RemoveUnusedModuleElements.cpp b/src/passes/RemoveUnusedModuleElements.cpp
index cd69894f3..f5000e3a4 100644
--- a/src/passes/RemoveUnusedModuleElements.cpp
+++ b/src/passes/RemoveUnusedModuleElements.cpp
@@ -130,24 +130,6 @@ struct ReachabilityAnalyzer : public PostWalker<ReachabilityAnalyzer> {
   }
 };
 
-// Finds function type usage
-
-struct FunctionTypeAnalyzer : public PostWalker<FunctionTypeAnalyzer> {
-  std::vector<Function*> functions;
-  std::vector<CallIndirect*> indirectCalls;
-  std::vector<Event*> events;
-
-  void visitFunction(Function* curr) {
-    if (curr->type.is()) {
-      functions.push_back(curr);
-    }
-  }
-
-  void visitEvent(Event* curr) { events.push_back(curr); }
-
-  void visitCallIndirect(CallIndirect* curr) { indirectCalls.push_back(curr); }
-};
-
 struct RemoveUnusedModuleElements : public Pass {
   bool rootAllFunctions;
 
@@ -155,11 +137,6 @@ struct RemoveUnusedModuleElements : public Pass {
     : rootAllFunctions(rootAllFunctions) {}
 
   void run(PassRunner* runner, Module* module) override {
-    optimizeGlobalsAndFunctionsAndEvents(module);
-    optimizeFunctionTypes(module);
-  }
-
-  void optimizeGlobalsAndFunctionsAndEvents(Module* module) {
     std::vector<ModuleElement> roots;
     // Module start is a root.
     if (module->start.is()) {
@@ -250,39 +227,6 @@ struct RemoveUnusedModuleElements : public Pass {
       }
     }
   }
-
-  void optimizeFunctionTypes(Module* module) {
-    FunctionTypeAnalyzer analyzer;
-    analyzer.walkModule(module);
-    // maps each string signature to a single canonical function type
-    std::unordered_map<std::string, FunctionType*> canonicals;
-    std::unordered_set<FunctionType*> needed;
-    auto canonicalize = [&](Name name) {
-      if (!name.is()) {
-        return name;
-      }
-      FunctionType* type = module->getFunctionType(name);
-      auto sig = getSig(type);
-      auto iter = canonicals.find(sig);
-      if (iter == canonicals.end()) {
-        needed.insert(type);
-        canonicals[sig] = type;
-        return type->name;
-      } else {
-        return iter->second->name;
-      }
-    };
-    // canonicalize all uses of function types
-    for (auto* func : analyzer.functions) {
-      func->type = canonicalize(func->type);
-    }
-    for (auto* call : analyzer.indirectCalls) {
-      call->fullType = canonicalize(call->fullType);
-    }
-    // remove no-longer used types
-    module->removeFunctionTypes(
-      [&](FunctionType* type) { return needed.count(type) == 0; });
-  }
 };
 
 Pass* createRemoveUnusedModuleElementsPass() {