[NFC] Remove HeapType from RefFunc::finalize

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

@@ -1694,8 +1694,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;
@@ -2988,10 +2987,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) {
@@ -3627,7 +3623,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);
@@ -3666,7 +3662,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());

src/wasm-builder.h

@@ -709,10 +709,10 @@ class Builder {
     ret->type = type;
     return ret;
   }
-  RefFunc* makeRefFunc(Name func, HeapType heapType) {
+  RefFunc* makeRefFunc(Name func) {
     auto* ret = wasm.allocator.alloc<RefFunc>();
     ret->func = func;
-    ret->finalize(heapType, wasm);
+    ret->finalize(wasm);
     return ret;
   }
   RefEq* makeRefEq(Expression* left, Expression* right) {
@@ -1368,7 +1368,7 @@ class Builder {
       return makeRefNull(type.getHeapType());
     }
     if (type.isFunction()) {
-      return makeRefFunc(value.getFunc(), type.getHeapType());
+      return makeRefFunc(value.getFunc());
     }
     if (type.isRef() && type.getHeapType().isMaybeShared(HeapType::i31)) {
       return makeRefI31(makeConst(value.geti31()),

src/wasm.h

@@ -1376,7 +1376,7 @@ class RefFunc : public SpecificExpression<Expression::RefFuncId> {
   Name func;
 
   void finalize();
-  void finalize(HeapType heapType, Module& wasm);
+  void finalize(Module& wasm);
 };
 
 class RefEq : public SpecificExpression<Expression::RefEqId> {

src/wasm/wasm-binary.cpp

@@ -4962,8 +4962,7 @@ void WasmBinaryReader::readElementSegments() {
     } else {
       for (Index j = 0; j < size; j++) {
         Index index = getU32LEB();
-        auto sig = getTypeByFunctionIndex(index);
-        auto* refFunc = Builder(wasm).makeRefFunc(getFunctionName(index), sig);
+        auto* refFunc = Builder(wasm).makeRefFunc(getFunctionName(index));
         segmentData.push_back(refFunc);
       }
     }

src/wasm/wasm-ir-builder.cpp

@@ -1736,7 +1736,7 @@ Result<> IRBuilder::makeRefIsNull() {
 }
 
 Result<> IRBuilder::makeRefFunc(Name func) {
-  push(builder.makeRefFunc(func, wasm.getFunction(func)->type.getHeapType()));
+  push(builder.makeRefFunc(func));
   return Ok{};
 }
 

src/wasm/wasm.cpp

@@ -827,11 +827,7 @@ void RefFunc::finalize() {
   assert(type.isSignature());
 }
 
-void RefFunc::finalize(HeapType heapType, Module& wasm) {
-  type = Type(heapType,
-              NonNullable,
-              wasm.getFunction(func)->imported() ? Inexact : Exact);
-}
+void RefFunc::finalize(Module& wasm) { type = wasm.getFunction(func)->type; }
 
 void RefEq::finalize() {
   if (left->type == Type::unreachable || right->type == Type::unreachable) {