[NFC] Remove HeapType from RefFunc::finalize (#8032)

Since finalization already looks up the function on the module to
determine whether it is imported, go further and just take the type
directly from the function.

Author: tlively

src/binaryen-c.cpp

@@ -1614,10 +1614,11 @@ BinaryenExpressionRef BinaryenRefFunc(BinaryenModuleRef module,
   // is non-imported if not. TODO: If we want to allow creating imports later,
   // we would need an API addition or change.
   auto* wasm = (Module*)module;
-  if (wasm->getFunctionOrNull(func)) {
+  if ([[maybe_unused]] auto* f = wasm->getFunctionOrNull(func)) {
+    assert(f->type.getHeapType() == HeapType(type));
     // Use the HeapType constructor, which will do a lookup on the module.
     return static_cast<Expression*>(
-      Builder(*(Module*)module).makeRefFunc(func, HeapType(type)));
+      Builder(*(Module*)module).makeRefFunc(func));
   } else {
     // Assume non-imported, and provide the full type for that.
     Type full = Type(HeapType(type), NonNullable, Exact);
@@ -5299,8 +5300,7 @@ BinaryenAddActiveElementSegment(BinaryenModuleRef module,
       Fatal() << "invalid function '" << funcNames[i] << "'.";
     }
     segment->data.push_back(
-      Builder(*(Module*)module)
-        .makeRefFunc(funcNames[i], func->type.getHeapType()));
+      Builder(*(Module*)module).makeRefFunc(funcNames[i]));
   }
   return ((Module*)module)->addElementSegment(std::move(segment));
 }
@@ -5317,8 +5317,7 @@ BinaryenAddPassiveElementSegment(BinaryenModuleRef module,
       Fatal() << "invalid function '" << funcNames[i] << "'.";
     }
     segment->data.push_back(
-      Builder(*(Module*)module)
-        .makeRefFunc(funcNames[i], func->type.getHeapType()));
+      Builder(*(Module*)module).makeRefFunc(funcNames[i]));
   }
   return ((Module*)module)->addElementSegment(std::move(segment));
 }

src/ir/ReFinalize.cpp

@@ -115,9 +115,7 @@ void ReFinalize::visitMemorySize(MemorySize* curr) { curr->finalize(); }
 void ReFinalize::visitMemoryGrow(MemoryGrow* curr) { curr->finalize(); }
 void ReFinalize::visitRefNull(RefNull* curr) { curr->finalize(); }
 void ReFinalize::visitRefIsNull(RefIsNull* curr) { curr->finalize(); }
-void ReFinalize::visitRefFunc(RefFunc* curr) {
-  curr->finalize(curr->type.getHeapType(), *getModule());
-}
+void ReFinalize::visitRefFunc(RefFunc* curr) { curr->finalize(*getModule()); }
 void ReFinalize::visitRefEq(RefEq* curr) { curr->finalize(); }
 void ReFinalize::visitTableGet(TableGet* curr) { curr->finalize(); }
 void ReFinalize::visitTableSet(TableSet* curr) { curr->finalize(); }

src/ir/possible-contents.h

@@ -327,8 +327,7 @@ class PossibleContents {
                                      wasm.getGlobal(info.name)->type);
       } else {
         assert(info.kind == ExternalKind::Function);
-        return builder.makeRefFunc(
-          info.name, wasm.getFunction(info.name)->type.getHeapType());
+        return builder.makeRefFunc(info.name);
       }
     }
   }

src/ir/table-utils.h

@@ -90,10 +90,9 @@ inline Index append(Table& table, Name name, Module& wasm) {
     wasm.dylinkSection->tableSize++;
   }
 
-  auto* func = wasm.getFunctionOrNull(name);
-  assert(func != nullptr && "Cannot append non-existing function to a table.");
-  segment->data.push_back(
-    Builder(wasm).makeRefFunc(name, func->type.getHeapType()));
+  assert(wasm.getFunctionOrNull(name) != nullptr &&
+         "Cannot append non-existing function to a table.");
+  segment->data.push_back(Builder(wasm).makeRefFunc(name));
   table.initial++;
   return tableIndex;
 }

src/passes/FuncCastEmulation.cpp

@@ -178,7 +178,7 @@ struct FuncCastEmulation : public Pass {
         }
         auto* thunk = iter->second;
         ref->func = thunk->name;
-        ref->finalize(thunk->type.getHeapType(), *module);
+        ref->finalize(*module);
       }
     }
 

src/passes/JSPI.cpp

@@ -151,9 +151,7 @@ struct JSPI : public Pass {
           if (iter == wrappedExports.end()) {
             continue;
           }
-          auto* replacementRef = builder.makeRefFunc(
-            iter->second,
-            module->getFunction(iter->second)->type.getHeapType());
+          auto* replacementRef = builder.makeRefFunc(iter->second);
           segment->data[i] = replacementRef;
         }
       }

src/passes/LegalizeJSInterface.cpp

@@ -148,7 +148,7 @@ struct LegalizeJSInterface : public Pass {
           }
 
           curr->func = iter->second->name;
-          curr->finalize(iter->second->type.getHeapType(), *getModule());
+          curr->finalize(*getModule());
         }
       };
 

src/passes/MergeSimilarFunctions.cpp

@@ -131,9 +131,7 @@ struct ParamInfo {
     if (const auto literals = std::get_if<Literals>(&values)) {
       return builder.makeConst((*literals)[index]);
     } else if (auto callees = std::get_if<std::vector<Name>>(&values)) {
-      auto fnName = (*callees)[index];
-      auto heapType = module->getFunction(fnName)->type.getHeapType();
-      return builder.makeRefFunc(fnName, heapType);
+      return builder.makeRefFunc((*callees)[index]);
     } else {
       WASM_UNREACHABLE("unexpected const value type");
     }

src/tools/fuzzing/fuzzing.cpp

@@ -1697,8 +1697,7 @@ Function* TranslateToFuzzReader::addFunction() {
       }
     });
     auto& randomElem = compatibleSegments[upTo(compatibleSegments.size())];
-    randomElem->data.push_back(
-      builder.makeRefFunc(func->name, func->type.getHeapType()));
+    randomElem->data.push_back(builder.makeRefFunc(func->name));
   }
   numAddedFunctions++;
   return func;
@@ -2991,10 +2990,7 @@ Expression* TranslateToFuzzReader::makeCallRef(Type type) {
   }
   // TODO: half the time make a completely random item with that type.
   return builder.makeCallRef(
-    builder.makeRefFunc(target->name, target->type.getHeapType()),
-    args,
-    type,
-    isReturn);
+    builder.makeRefFunc(target->name), args, type, isReturn);
 }
 
 Expression* TranslateToFuzzReader::makeLocalGet(Type type) {
@@ -3630,7 +3626,7 @@ Expression* TranslateToFuzzReader::makeRefFuncConst(Type type) {
     do {
       auto& func = wasm.functions[i];
       if (Type::isSubType(func->type, type)) {
-        return builder.makeRefFunc(func->name, func->type.getHeapType());
+        return builder.makeRefFunc(func->name);
       }
       i = (i + 1) % wasm.functions.size();
     } while (i != start);
@@ -3669,7 +3665,7 @@ Expression* TranslateToFuzzReader::makeRefFuncConst(Type type) {
                          Type(heapType, NonNullable, Exact),
                          {},
                          body));
-  return builder.makeRefFunc(func->name, heapType);
+  return builder.makeRefFunc(func->name);
 }
 
 Expression* TranslateToFuzzReader::makeConst(Type type) {

src/tools/wasm-merge.cpp

@@ -584,10 +584,7 @@ void updateTypes(Module& wasm) {
       }
     }
 
-    void visitRefFunc(RefFunc* curr) {
-      curr->finalize(getModule()->getFunction(curr->func)->type.getHeapType(),
-                     *getModule());
-    }
+    void visitRefFunc(RefFunc* curr) { curr->finalize(*getModule()); }
 
     void visitFunction(Function* curr) {
       ReFinalize().walkFunctionInModule(curr, getModule());