Optimize logic for walking up supertype heirarchy

Author: stevenfontanella

src/passes/GlobalEffects.cpp

@@ -24,6 +24,7 @@
 #include "ir/effects.h"
 #include "ir/module-utils.h"
 #include "pass.h"
+#include "support/graph_traversal.h"
 #include "support/strongly_connected_components.h"
 #include "wasm.h"
 
@@ -148,6 +149,18 @@ CallGraph buildCallGraph(const Module& module,
                          const std::map<Function*, FuncInfo>& funcInfos,
                          bool closedWorld) {
   CallGraph callGraph;
+  if (!closedWorld) {
+    for (const auto& [caller, callerInfo] : funcInfos) {
+      auto& callees = callGraph[caller];
+
+      // Function -> Function
+      for (Name calleeFunction : callerInfo.calledFunctions) {
+        callees.insert(module.getFunction(calleeFunction));
+      }
+    }
+
+    return callGraph;
+  }
 
   std::unordered_set<HeapType> allFunctionTypes;
   for (const auto& [caller, callerInfo] : funcInfos) {
@@ -158,9 +171,6 @@ CallGraph buildCallGraph(const Module& module,
       callees.insert(module.getFunction(calleeFunction));
     }
 
-    if (!closedWorld) {
-      continue;
-    }
     // Function -> Type
     allFunctionTypes.insert(caller->type.getHeapType());
     for (HeapType calleeType : callerInfo.indirectCalledTypes) {
@@ -176,16 +186,21 @@ CallGraph buildCallGraph(const Module& module,
   }
 
   // Type -> Type
-  for (HeapType type : allFunctionTypes) {
-    // Not needed except that during lookup we expect the key to exist.
-    callGraph[type];
-
-    HeapType curr = type;
-    while (std::optional<HeapType> super = curr.getDeclaredSuperType()) {
-      callGraph[*super].insert(type);
-      curr = *super;
-    }
-  }
+  // Do a DFS up the type heirarchy for all function implementations.
+  // We are essentially walking up each supertype chain and adding edges from
+  // super -> subtype, but doing it via DFS to avoid repeated work.
+  Graph superTypeGraph(allFunctionTypes.begin(),
+          allFunctionTypes.end(),
+          [&callGraph](auto&& push, HeapType t) {
+            // Not needed except that during lookup we expect the key to exist.
+            callGraph[t];
+
+            if (auto super = t.getDeclaredSuperType()) {
+              callGraph[*super].insert(t);
+              push(*super);
+            }
+          });
+  (void)superTypeGraph.traverseDepthFirst();
 
   return callGraph;
 }

src/support/graph_traversal.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2026 WebAssembly Community Group participants
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <concepts>
+
+namespace wasm {
+
+template<typename T, typename SuccessorFunction>
+  requires std::invocable<SuccessorFunction, std::function<void(const T&)>&, const T&>
+class Graph {
+public:
+  template<std::input_iterator It, std::sentinel_for<It> Sen>
+    requires std::convertible_to<std::iter_reference_t<It>, T>
+  Graph(It rootsBegin, Sen rootsEnd, auto&& successors)
+    : roots(rootsBegin, rootsEnd),
+      successors(std::forward<decltype(successors)>(successors)) {}
+
+  std::unordered_set<T> traverseDepthFirst() const {
+    std::vector<T> stack(roots.begin(), roots.end());
+    std::unordered_set<T> visited(roots.begin(), roots.end());
+
+    while (!stack.empty()) {
+      auto curr = std::move(stack.back());
+      stack.pop_back();
+
+      auto maybePush = [&](const T& t) {
+        if (visited.contains(t)) {
+          return;
+        }
+
+        visited.insert(t);
+        stack.push_back(t);
+      };
+
+      successors(maybePush, curr);
+    }
+
+    return visited;
+  }
+
+private:
+  std::vector<T> roots;
+  SuccessorFunction successors;
+};
+
+template<std::input_iterator It,
+         std::sentinel_for<It> Sen,
+         typename SuccessorFunction>
+Graph(It, Sen, SuccessorFunction)
+  -> Graph<std::iter_value_t<It>, std::decay_t<SuccessorFunction>>;
+
+} // namespace wasm