Replace the old topological sort everywhere

To avoid having two separate topological sort utilities in the code base,
replace remaining uses of the old DFS-based, CRTP topological sort with the
newer Kahn's algorithm implementation.

This would be NFC, except that the new topological sort produces a different
order than the old topological sort, so the output of some passes is reordered.

Author: tlively

Diff for: src/ir/subtypes.h

@@ -18,7 +18,7 @@
 #define wasm_ir_subtypes_h
 
 #include "ir/module-utils.h"
-#include "support/topological_sort.h"
+#include "support/topological_orders.h"
 #include "wasm.h"
 
 namespace wasm {
@@ -79,29 +79,19 @@ struct SubTypes {
   }
 
   // A topological sort that visits subtypes first.
-  auto getSubTypesFirstSort() const {
-    struct SubTypesFirstSort : TopologicalSort<HeapType, SubTypesFirstSort> {
-      const SubTypes& parent;
-
-      SubTypesFirstSort(const SubTypes& parent) : parent(parent) {
-        for (auto type : parent.types) {
-          // The roots are types with no supertype.
-          if (!type.getDeclaredSuperType()) {
-            push(type);
-          }
-        }
-      }
-
-      void pushPredecessors(HeapType type) {
-        // Things we need to process before each type are its subtypes. Once we
-        // know their depth, we can easily compute our own.
-        for (auto pred : parent.getImmediateSubTypes(type)) {
-          push(pred);
-        }
+  std::vector<HeapType> getSubTypesFirstSort() const {
+    std::vector<std::pair<HeapType, std::vector<HeapType>>> graph;
+    graph.reserve(types.size());
+    for (auto type : types) {
+      if (auto it = typeSubTypes.find(type); it != typeSubTypes.end()) {
+        graph.emplace_back(*it);
+      } else {
+        graph.emplace_back(type, std::vector<HeapType>{});
       }
-    };
-
-    return SubTypesFirstSort(*this);
+    }
+    auto sorted = TopologicalSort::sortOf(graph.begin(), graph.end());
+    std::reverse(sorted.begin(), sorted.end());
+    return sorted;
   }
 
   // Computes the depth of children for each type. This is 0 if the type has no

Diff for: src/ir/type-updating.cpp

@@ -20,7 +20,6 @@
 #include "ir/module-utils.h"
 #include "ir/names.h"
 #include "ir/utils.h"
-#include "support/topological_sort.h"
 #include "wasm-type-ordering.h"
 #include "wasm-type.h"
 #include "wasm.h"
@@ -59,18 +58,12 @@ GlobalTypeRewriter::TypeMap GlobalTypeRewriter::rebuildTypes(
 
   // Topological sort to have supertypes first, but we have to account for the
   // fact that we may be replacing the supertypes to get the order correct.
-  struct SupertypesFirst
-    : HeapTypeOrdering::SupertypesFirstBase<SupertypesFirst> {
-    GlobalTypeRewriter& parent;
-
-    SupertypesFirst(GlobalTypeRewriter& parent) : parent(parent) {}
-    std::optional<HeapType> getDeclaredSuperType(HeapType type) {
-      return parent.getDeclaredSuperType(type);
-    }
+  auto supertypesFirst = [this](const auto& types) {
+    return HeapTypeOrdering::supertypesFirst(
+      types, [this](HeapType type) { return getDeclaredSuperType(type); });
   };
 
-  SupertypesFirst sortedTypes(*this);
-  for (auto type : sortedTypes.sort(privateTypes)) {
+  for (auto type : supertypesFirst(privateTypes)) {
     typeIndices[type] = i++;
   }
 

Diff for: src/passes/GlobalTypeOptimization.cpp

@@ -171,8 +171,8 @@ struct GlobalTypeOptimization : public Pass {
     // fields in a supertype is a constraint on what subtypes can do. That is,
     // we decide for each supertype what the optimal order is, and consider that
     // fixed, and then subtypes can decide how to sort fields that they append.
-    HeapTypeOrdering::SupertypesFirst sorted;
-    for (auto type : sorted.sort(propagator.subTypes.types)) {
+    for (auto type :
+         HeapTypeOrdering::supertypesFirst(propagator.subTypes.types)) {
       if (!type.isStruct()) {
         continue;
       }

Diff for: src/passes/TypeMerging.cpp

@@ -142,6 +142,17 @@ struct TypeMerging : public Pass {
     return type;
   }
 
+  std::vector<HeapType>
+  mergeableSupertypesFirst(const std::vector<HeapType>& types) {
+    return HeapTypeOrdering::supertypesFirst(
+      types, [&](HeapType type) -> std::optional<HeapType> {
+        if (auto super = type.getDeclaredSuperType()) {
+          return getMerged(*super);
+        }
+        return std::nullopt;
+      });
+  }
+
   void run(Module* module_) override;
 
   // We will do two different kinds of merging: First, we will merge types into
@@ -163,20 +174,6 @@ struct TypeMerging : public Pass {
   void applyMerges();
 };
 
-struct MergeableSupertypesFirst
-  : HeapTypeOrdering::SupertypesFirstBase<MergeableSupertypesFirst> {
-  TypeMerging& merging;
-
-  MergeableSupertypesFirst(TypeMerging& merging) : merging(merging) {}
-
-  std::optional<HeapType> getDeclaredSuperType(HeapType type) {
-    if (auto super = type.getDeclaredSuperType()) {
-      return merging.getMerged(*super);
-    }
-    return std::nullopt;
-  }
-};
-
 // Hash and equality-compare HeapTypes based on their top-level structure (i.e.
 // "shape"), ignoring nontrivial heap type children that will not be
 // differentiated between until we run the DFA partition refinement.
@@ -305,8 +302,7 @@ bool TypeMerging::merge(MergeKind kind) {
 
   // For each type, either create a new partition or add to its supertype's
   // partition.
-  MergeableSupertypesFirst sortedTypes(*this);
-  for (auto type : sortedTypes.sort(mergeable)) {
+  for (auto type : mergeableSupertypesFirst(mergeable)) {
     // We need partitions for any public children of this type since those
     // children will participate in the DFA we're creating.
     for (auto child : getPublicChildren(type)) {
@@ -414,7 +410,7 @@ bool TypeMerging::merge(MergeKind kind) {
   std::vector<HeapType> newMergeable;
   bool merged = false;
   for (const auto& partition : refinedPartitions) {
-    auto target = *MergeableSupertypesFirst(*this).sort(partition).begin();
+    auto target = mergeableSupertypesFirst(partition).front();
     newMergeable.push_back(target);
     for (auto type : partition) {
       if (type != target) {
@@ -452,8 +448,7 @@ TypeMerging::splitSupertypePartition(const std::vector<HeapType>& types) {
   std::unordered_set<HeapType> includedTypes(types.begin(), types.end());
   std::vector<std::vector<HeapType>> partitions;
   std::unordered_map<HeapType, Index> partitionIndices;
-  MergeableSupertypesFirst sortedTypes(*this);
-  for (auto type : sortedTypes.sort(types)) {
+  for (auto type : mergeableSupertypesFirst(types)) {
     auto super = type.getDeclaredSuperType();
     if (super && includedTypes.count(*super)) {
       // We must already have a partition for the supertype we can add to.

Diff for: src/support/topological_sort.h

@@ -38,7 +38,7 @@
 #include "support/insert_ordered.h"
 #include "support/small_set.h"
 #include "support/string.h"
-#include "support/topological_sort.h"
+#include "support/topological_orders.h"
 #include "tool-options.h"
 #include "wasm-builder.h"
 #include "wasm-interpreter.h"
@@ -609,9 +609,9 @@ struct CtorEvalExternalInterface : EvallingModuleRunner::ExternalInterface {
     Builder builder(*wasm);
 
     // First, find what constraints we have on the ordering of the globals. We
-    // will build up a map of each global to the globals it must be after.
-    using MustBeAfter = InsertOrderedMap<Name, InsertOrderedSet<Name>>;
-    MustBeAfter mustBeAfter;
+    // will build up a map of each global to the globals it must be before.
+    using MustBeBefore = InsertOrderedMap<Name, InsertOrderedSet<Name>>;
+    MustBeBefore mustBeBefore;
 
     for (auto& global : wasm->globals) {
       if (!global->init) {
@@ -672,31 +672,12 @@ struct CtorEvalExternalInterface : EvallingModuleRunner::ExternalInterface {
 
       // Any global.gets that cannot be fixed up are constraints.
       for (auto* get : scanner.unfixableGets) {
-        mustBeAfter[global->name].insert(get->name);
+        mustBeBefore[global->name];
+        mustBeBefore[get->name].insert(global->name);
       }
     }
 
-    if (!mustBeAfter.empty()) {
-      // We found constraints that require reordering, so do so.
-      struct MustBeAfterSort : TopologicalSort<Name, MustBeAfterSort> {
-        MustBeAfter& mustBeAfter;
-
-        MustBeAfterSort(MustBeAfter& mustBeAfter) : mustBeAfter(mustBeAfter) {
-          for (auto& [global, _] : mustBeAfter) {
-            push(global);
-          }
-        }
-
-        void pushPredecessors(Name global) {
-          auto iter = mustBeAfter.find(global);
-          if (iter != mustBeAfter.end()) {
-            for (auto other : iter->second) {
-              push(other);
-            }
-          }
-        }
-      };
-
+    if (!mustBeBefore.empty()) {
       auto oldGlobals = std::move(wasm->globals);
       // After clearing the globals vector, clear the map as well.
       wasm->updateMaps();
@@ -706,7 +687,8 @@ struct CtorEvalExternalInterface : EvallingModuleRunner::ExternalInterface {
         globalIndexes[oldGlobals[i]->name] = i;
       }
       // Add the globals that had an important ordering, in the right order.
-      for (auto global : MustBeAfterSort(mustBeAfter)) {
+      for (auto global :
+           TopologicalSort::sortOf(mustBeBefore.begin(), mustBeBefore.end())) {
         wasm->addGlobal(std::move(oldGlobals[globalIndexes[global]]));
       }
       // Add all other globals after them.