Store HeapTypes in Tags (#7220)

Tags in WebAssembly syntactically refer to function heap types, but
Binaryen IR was previously storing signatures instead and reconstructing
heap types as necessary when emitting binaries. Before WasmGC this was
not a problem because the reconstructed types would be the same as the
original types, but with WasmGC round tripping function types through
Signature could lose information such as the rec group, the declared
supertype, and the finality from the original type. Store the original
heap type in the IR instead to stop losing this information.

Fixes #7219.

Author: tlively

src/binaryen-c.cpp

@@ -4770,7 +4770,7 @@ BinaryenTagRef BinaryenAddTag(BinaryenModuleRef module,
                               BinaryenType results) {
   auto* ret = new Tag();
   ret->setExplicitName(name);
-  ret->sig = Signature(Type(params), Type(results));
+  ret->type = Signature(Type(params), Type(results));
   ((Module*)module)->addTag(ret);
   return ret;
 }
@@ -4874,7 +4874,7 @@ void BinaryenAddTagImport(BinaryenModuleRef module,
     tag->name = internalName;
     tag->module = externalModuleName;
     tag->base = externalBaseName;
-    tag->sig = Signature(Type(params), Type(results));
+    tag->type = Signature(Type(params), Type(results));
     ((Module*)module)->addTag(std::move(tag));
   } else {
     // already exists so just set module and base
@@ -5838,11 +5838,11 @@ const char* BinaryenTagGetName(BinaryenTagRef tag) {
   return ((Tag*)tag)->name.str.data();
 }
 BinaryenType BinaryenTagGetParams(BinaryenTagRef tag) {
-  return ((Tag*)tag)->sig.params.getID();
+  return ((Tag*)tag)->params().getID();
 }
 
 BinaryenType BinaryenTagGetResults(BinaryenTagRef tag) {
-  return ((Tag*)tag)->sig.results.getID();
+  return ((Tag*)tag)->results().getID();
 }
 
 //

src/ir/child-typer.h

@@ -789,7 +789,7 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {
   void visitTryTable(TryTable* curr) { note(&curr->body, curr->type); }
 
   void visitThrow(Throw* curr) {
-    auto type = wasm.getTag(curr->tag)->sig.params;
+    auto type = wasm.getTag(curr->tag)->params();
     assert(curr->operands.size() == type.size());
     for (size_t i = 0; i < type.size(); ++i) {
       note(&curr->operands[i], type[i]);
@@ -1113,7 +1113,7 @@ template<typename Subtype> struct ChildTyper : OverriddenVisitor<Subtype> {
   }
 
   void visitSuspend(Suspend* curr) {
-    auto params = wasm.getTag(curr->tag)->sig.params;
+    auto params = wasm.getTag(curr->tag)->params();
     assert(params.size() == curr->operands.size());
     for (size_t i = 0; i < params.size(); ++i) {
       note(&curr->operands[i], params[i]);

src/ir/eh-utils.cpp

@@ -111,7 +111,7 @@ void handleBlockNestedPop(Try* try_, Function* func, Module& wasm) {
   for (Index i = 0; i < try_->catchTags.size(); i++) {
     Name tagName = try_->catchTags[i];
     auto* tag = wasm.getTag(tagName);
-    if (tag->sig.params == Type::none) {
+    if (tag->params() == Type::none) {
       continue;
     }
 

src/ir/module-splitting.cpp

@@ -883,7 +883,7 @@ void ModuleSplitter::shareImportableItems() {
 
   for (auto& tag : primary.tags) {
     auto secondaryTag = std::make_unique<Tag>();
-    secondaryTag->sig = tag->sig;
+    secondaryTag->type = tag->type;
     makeImportExport(*tag, *secondaryTag, "tag", ExternalKind::Tag);
     secondary.addTag(std::move(secondaryTag));
   }

src/ir/module-utils.cpp

@@ -125,7 +125,7 @@ Tag* copyTag(Tag* tag, Module& out) {
   auto* ret = new Tag();
   ret->name = tag->name;
   ret->hasExplicitName = tag->hasExplicitName;
-  ret->sig = tag->sig;
+  ret->type = tag->type;
   ret->module = tag->module;
   ret->base = tag->base;
   out.addTag(ret);
@@ -474,7 +474,7 @@ InsertOrderedMap<HeapType, HeapTypeInfo> collectHeapTypeInfo(
     info.note(curr->type);
   }
   for (auto& curr : wasm.tags) {
-    info.note(curr->sig);
+    info.note(curr->type);
   }
   for (auto& curr : wasm.tables) {
     info.note(curr->type);

src/ir/possible-contents.cpp

@@ -1151,7 +1151,7 @@ struct InfoCollector
       auto tag = curr->catchTags[tagIndex];
       auto* body = curr->catchBodies[tagIndex];
 
-      auto params = getModule()->getTag(tag)->sig.params;
+      auto params = getModule()->getTag(tag)->params();
       if (params.size() == 0) {
         continue;
       }
@@ -1189,7 +1189,7 @@ struct InfoCollector
 
       Index exnrefIndex = 0;
       if (tag.is()) {
-        auto params = getModule()->getTag(tag)->sig.params;
+        auto params = getModule()->getTag(tag)->params();
 
         for (Index i = 0; i < params.size(); i++) {
           if (isRelevant(params[i])) {

src/ir/subtype-exprs.h

@@ -257,7 +257,7 @@ struct SubtypingDiscoverer : public OverriddenVisitor<SubType> {
     }
   }
   void visitThrow(Throw* curr) {
-    Type params = self()->getModule()->getTag(curr->tag)->sig.params;
+    Type params = self()->getModule()->getTag(curr->tag)->params();
     assert(params.size() == curr->operands.size());
     for (size_t i = 0, size = curr->operands.size(); i < size; ++i) {
       self()->noteSubtype(curr->operands[i], params[i]);

src/ir/type-updating.cpp

@@ -225,10 +225,6 @@ void GlobalTypeRewriter::mapTypes(const TypeMap& oldToNewTypes) {
       return type;
     }
 
-    Signature getNew(Signature sig) {
-      return Signature(getNew(sig.params), getNew(sig.results));
-    }
-
     void visitExpression(Expression* curr) {
       // local.get and local.tee are special in that their type is tied to the
       // type of the local in the function, which is tied to the signature. That
@@ -304,7 +300,7 @@ void GlobalTypeRewriter::mapTypes(const TypeMap& oldToNewTypes) {
     global->type = updater.getNew(global->type);
   }
   for (auto& tag : wasm.tags) {
-    tag->sig = updater.getNew(tag->sig);
+    tag->type = updater.getNew(tag->type);
   }
 }
 

src/parser/contexts.h

@@ -1372,7 +1372,7 @@ struct ParseModuleTypesCtx : TypeParserCtx<ParseModuleTypesCtx>,
     if (!use.type.isSignature()) {
       return in.err(pos, "tag type must be a signature");
     }
-    t->sig = use.type.getSignature();
+    t->type = use.type;
     return Ok{};
   }
 };

src/passes/MergeBlocks.cpp

@@ -144,7 +144,7 @@ struct ProblemFinder
           //       make more sense in TupleOptimization though as it would need
           //       to track uses of parts of a tuple.
           if (!tryy->catchTags[i] ||
-              getModule()->getTag(tryy->catchTags[i])->sig.params.size() == 0) {
+              getModule()->getTag(tryy->catchTags[i])->params().size() == 0) {
             // There must be a ref here, otherwise there is no value being sent
             // at all, and we should not be running ProblemFinder at all.
             assert(tryy->catchRefs[i]);