ModuleHeapType

Author: tlively

src/passes/Print.cpp

@@ -3903,4 +3903,12 @@ std::ostream& operator<<(std::ostream& o, wasm::ModuleType pair) {
   return o;
 }
 
+std::ostream& operator<<(std::ostream& o, wasm::ModuleHeapType pair) {
+  if (auto it = pair.first.typeNames.find(pair.second);
+      it != pair.first.typeNames.end()) {
+    return o << it->second.name;
+  }
+  return o << "(unnamed)";
+}
+
 } // namespace std

src/passes/Unsubtyping.cpp

@@ -129,15 +129,6 @@ template<typename K, typename V> using Map = std::unordered_map<K, V>;
 template<typename T> using Set = std::unordered_set<T>;
 #endif
 
-#if UNSUBTYPING_DEBUG
-Name getTypeName(Module& wasm, HeapType type) {
-  if (auto it = wasm.typeNames.find(type); it != wasm.typeNames.end()) {
-    return it->second.name;
-  }
-  return Name("(unnamed)");
-}
-#endif
-
 // A tree (or rather a forest) of types with the ability to query and set
 // supertypes in constant time and efficiently iterate over supertypes and
 // subtypes.
@@ -291,13 +282,13 @@ struct TypeTree {
 #if UNSUBTYPING_DEBUG
   void dump(Module& wasm) {
     for (auto& node : nodes) {
-      std::cerr << getTypeName(wasm, node.type);
+      std::cerr << ModuleHeapType(wasm, node.type);
       if (auto super = getSupertype(node.type)) {
-        std::cerr << " <: " << getTypeName(wasm, *super);
+        std::cerr << " <: " << ModuleHeapType(wasm, *super);
       }
       std::cerr << ", children:";
       for (auto child : node.children) {
-        std::cerr << " " << getTypeName(wasm, nodes[child].type);
+        std::cerr << " " << ModuleHeapType(wasm, nodes[child].type);
       }
       std::cerr << '\n';
     }
@@ -360,8 +351,8 @@ struct Unsubtyping : Pass {
     if (sub == super || sub.isBottom()) {
       return;
     }
-    DBG(std::cerr << "noting " << getTypeName(*wasm, sub)
-                  << " <: " << getTypeName(*wasm, super) << '\n');
+    DBG(std::cerr << "noting " << ModuleHeapType(*wasm, sub)
+                  << " <: " << ModuleHeapType(*wasm, super) << '\n');
     work.push_back({sub, super});
   }
 
@@ -520,8 +511,8 @@ struct Unsubtyping : Pass {
   }
 
   void process(HeapType sub, HeapType super) {
-    DBG(std::cerr << "processing " << getTypeName(*wasm, sub)
-                  << " <: " << getTypeName(*wasm, super) << '\n');
+    DBG(std::cerr << "processing " << ModuleHeapType(*wasm, sub)
+                  << " <: " << ModuleHeapType(*wasm, super) << '\n');
     assert(HeapType::isSubType(sub, super));
     auto oldSuper = types.getSupertype(sub);
     if (oldSuper) {

src/wasm.h

@@ -2623,8 +2623,9 @@ class Module {
 // Utility for printing an expression with named types.
 using ModuleExpression = std::pair<Module&, Expression*>;
 
-// Utility for printing an type with a name, if the module defines a name.
+// Utilities for printing an type with a name, if the module defines a name.
 using ModuleType = std::pair<Module&, Type>;
+using ModuleHeapType = std::pair<Module&, HeapType>;
 
 // Utility for printing only the top level of an expression. Named types will be
 // used if `module` is non-null.
@@ -2648,6 +2649,7 @@ std::ostream& operator<<(std::ostream& o, wasm::Expression& expression);
 std::ostream& operator<<(std::ostream& o, wasm::ModuleExpression pair);
 std::ostream& operator<<(std::ostream& o, wasm::ShallowExpression expression);
 std::ostream& operator<<(std::ostream& o, wasm::ModuleType pair);
+std::ostream& operator<<(std::ostream& o, wasm::ModuleHeapType pair);
 
 } // namespace std