3 files changed, 15 insertions, 13 deletions

diff --git a/src/ir/type-updating.cpp b/src/ir/type-updating.cpp
index 59b77cca1..642992d7e 100644
--- a/src/ir/type-updating.cpp
+++ b/src/ir/type-updating.cpp
@@ -45,15 +45,14 @@ GlobalTypeRewriter::TypeMap GlobalTypeRewriter::rebuildTypes() {
     : HeapTypeOrdering::SupertypesFirstBase<SupertypesFirst> {
     GlobalTypeRewriter& parent;
 
-    SupertypesFirst(GlobalTypeRewriter& parent,
-                    const std::vector<HeapType>& types)
-      : SupertypesFirstBase(types), parent(parent) {}
+    SupertypesFirst(GlobalTypeRewriter& parent) : parent(parent) {}
     std::optional<HeapType> getSuperType(HeapType type) {
       return parent.getSuperType(type);
     }
   };
 
-  for (auto type : SupertypesFirst(*this, privateTypes)) {
+  SupertypesFirst sortedTypes(*this);
+  for (auto type : sortedTypes.sort(privateTypes)) {
     typeIndices[type] = i++;
   }
 
diff --git a/src/passes/TypeMerging.cpp b/src/passes/TypeMerging.cpp
index 3d7a032b5..7bd4ad7fe 100644
--- a/src/passes/TypeMerging.cpp
+++ b/src/passes/TypeMerging.cpp
@@ -167,9 +167,7 @@ struct MergeableSupertypesFirst
   : HeapTypeOrdering::SupertypesFirstBase<MergeableSupertypesFirst> {
   TypeMerging& merging;
 
-  template<typename T>
-  MergeableSupertypesFirst(TypeMerging& merging, const T& types)
-    : SupertypesFirstBase(types), merging(merging) {}
+  MergeableSupertypesFirst(TypeMerging& merging) : merging(merging) {}
 
   std::optional<HeapType> getSuperType(HeapType type) {
     if (auto super = type.getSuperType()) {
@@ -307,7 +305,8 @@ bool TypeMerging::merge(MergeKind kind) {
 
   // For each type, either create a new partition or add to its supertype's
   // partition.
-  for (auto type : MergeableSupertypesFirst(*this, mergeable)) {
+  MergeableSupertypesFirst sortedTypes(*this);
+  for (auto type : sortedTypes.sort(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)) {
@@ -415,7 +414,7 @@ bool TypeMerging::merge(MergeKind kind) {
   std::vector<HeapType> newMergeable;
   bool merged = false;
   for (const auto& partition : refinedPartitions) {
-    auto target = *MergeableSupertypesFirst(*this, partition).begin();
+    auto target = *MergeableSupertypesFirst(*this).sort(partition).begin();
     newMergeable.push_back(target);
     for (auto type : partition) {
       if (type != target) {
@@ -453,7 +452,8 @@ 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;
-  for (auto type : MergeableSupertypesFirst(*this, types)) {
+  MergeableSupertypesFirst sortedTypes(*this);
+  for (auto type : sortedTypes.sort(types)) {
     auto super = type.getSuperType();
     if (super && includedTypes.count(*super)) {
       // We must already have a partition for the supertype we can add to.
diff --git a/src/wasm-type-ordering.h b/src/wasm-type-ordering.h
index af1995de4..400ac014a 100644
--- a/src/wasm-type-ordering.h
+++ b/src/wasm-type-ordering.h
@@ -35,13 +35,15 @@ struct SupertypesFirstBase
   // track membership in the input collection.
   InsertOrderedMap<HeapType, bool> typeSet;
 
-  template<typename T> SupertypesFirstBase(const T& types) {
+  SupertypeProvider& self() { return *static_cast<SupertypeProvider*>(this); }
+
+  template<typename T> SupertypeProvider& sort(const T& types) {
     for (auto type : types) {
       typeSet[type] = false;
     }
     // Find the supertypes that are in the collection.
     for (auto [type, _] : typeSet) {
-      if (auto super = type.getSuperType()) {
+      if (auto super = self().getSuperType(type)) {
         if (auto it = typeSet.find(*super); it != typeSet.end()) {
           it->second = true;
         }
@@ -53,11 +55,12 @@ struct SupertypesFirstBase
         this->push(type);
       }
     }
+    return self();
   }
 
   void pushPredecessors(HeapType type) {
     // Do not visit types that weren't in the input collection.
-    if (auto super = static_cast<SupertypeProvider*>(this)->getSuperType(type);
+    if (auto super = self().getSuperType(type);
         super && typeSet.count(*super)) {
       this->push(*super);
     }