Code improvements for call ref and br_on_[non_]null

zherczeg · zherczeg · commit 574d7738f9c5 · 2025-11-09T06:53:25.000Z
diff --git a/include/wabt/type-checker.h b/include/wabt/type-checker.h
@@ -97,12 +97,16 @@ class TypeChecker {
   Result OnCallIndirect(const TypeVector& param_types,
                         const TypeVector& result_types,
                         const Limits& table_limits);
-  Result OnCallRef(Type);
+  Result OnCallRef(Type type,
+                   const TypeVector& param_types,
+                   const TypeVector& result_types);
   Result OnReturnCall(const TypeVector& param_types,
                       const TypeVector& result_types);
   Result OnReturnCallIndirect(const TypeVector& param_types,
                               const TypeVector& result_types);
-  Result OnReturnCallRef(Type);
+  Result OnReturnCallRef(Type type,
+                         const TypeVector& param_types,
+                         const TypeVector& result_types);
   Result OnCatch(const TypeVector& sig);
   Result OnCompare(Opcode);
   Result OnConst(Type);
@@ -191,6 +195,8 @@ class TypeChecker {
   Result PopAndCheckCall(const TypeVector& param_types,
                          const TypeVector& result_types,
                          const char* desc);
+  Result PopAndCheckReturnCall(const TypeVector& result_types,
+                               const char* desc);
   Result PopAndCheck1Type(Type expected, const char* desc);
   Result PopAndCheck2Types(Type expected1, Type expected2, const char* desc);
   Result PopAndCheck3Types(Type expected1,
diff --git a/src/apply-names.cc b/src/apply-names.cc
@@ -98,6 +98,7 @@ class NameApplier : public ExprVisitor::DelegateNop {
   Result UseNameForDataSegmentVar(Var* var);
   Result UseNameForElemSegmentVar(Var* var);
   Result UseNameForParamAndLocalVar(Func* func, Var* var);
+  Result UseNameForLabelVar(Var* var);
   Result VisitFunc(Index func_index, Func* func);
   Result VisitGlobal(Global* global);
   Result VisitTag(Tag* tag);
@@ -241,6 +242,12 @@ Result NameApplier::UseNameForParamAndLocalVar(Func* func, Var* var) {
   return Result::Ok;
 }
 
+Result NameApplier::UseNameForLabelVar(Var* var) {
+  std::string_view label = FindLabelByVar(var);
+  UseNameForVar(label, var);
+  return Result::Ok;
+}
+
 Result NameApplier::BeginBlockExpr(BlockExpr* expr) {
   PushLabel(expr->block.label);
   return Result::Ok;
@@ -341,37 +348,31 @@ Result NameApplier::OnStoreExpr(StoreExpr* expr) {
 }
 
 Result NameApplier::OnBrExpr(BrExpr* expr) {
-  std::string_view label = FindLabelByVar(&expr->var);
-  UseNameForVar(label, &expr->var);
+  UseNameForLabelVar(&expr->var);
   return Result::Ok;
 }
 
 Result NameApplier::OnBrIfExpr(BrIfExpr* expr) {
-  std::string_view label = FindLabelByVar(&expr->var);
-  UseNameForVar(label, &expr->var);
+  UseNameForLabelVar(&expr->var);
   return Result::Ok;
 }
 
 Result NameApplier::OnBrOnNonNullExpr(BrOnNonNullExpr* expr) {
-  std::string_view label = FindLabelByVar(&expr->var);
-  UseNameForVar(label, &expr->var);
+  UseNameForLabelVar(&expr->var);
   return Result::Ok;
 }
 
 Result NameApplier::OnBrOnNullExpr(BrOnNullExpr* expr) {
-  std::string_view label = FindLabelByVar(&expr->var);
-  UseNameForVar(label, &expr->var);
+  UseNameForLabelVar(&expr->var);
   return Result::Ok;
 }
 
 Result NameApplier::OnBrTableExpr(BrTableExpr* expr) {
   for (Var& target : expr->targets) {
-    std::string_view label = FindLabelByVar(&target);
-    UseNameForVar(label, &target);
+    UseNameForLabelVar(&target);
   }
 
-  std::string_view label = FindLabelByVar(&expr->default_target);
-  UseNameForVar(label, &expr->default_target);
+  UseNameForLabelVar(&expr->default_target);
   return Result::Ok;
 }
 
@@ -390,8 +391,7 @@ Result NameApplier::BeginTryTableExpr(TryTableExpr* expr) {
     if (!catch_.IsCatchAll()) {
       CHECK_RESULT(UseNameForTagVar(&catch_.tag));
     }
-    std::string_view label = FindLabelByVar(&catch_.target);
-    UseNameForVar(label, &catch_.target);
+    UseNameForLabelVar(&catch_.target);
   }
   PushLabel(expr->block.label);
   return Result::Ok;
@@ -411,8 +411,7 @@ Result NameApplier::OnCatchExpr(TryExpr*, Catch* expr) {
 
 Result NameApplier::OnDelegateExpr(TryExpr* expr) {
   PopLabel();
-  std::string_view label = FindLabelByVar(&expr->delegate_target);
-  UseNameForVar(label, &expr->delegate_target);
+  UseNameForLabelVar(&expr->delegate_target);
   return Result::Ok;
 }
 
@@ -422,8 +421,7 @@ Result NameApplier::OnThrowExpr(ThrowExpr* expr) {
 }
 
 Result NameApplier::OnRethrowExpr(RethrowExpr* expr) {
-  std::string_view label = FindLabelByVar(&expr->var);
-  UseNameForVar(label, &expr->var);
+  UseNameForLabelVar(&expr->var);
   return Result::Ok;
 }
 
diff --git a/src/shared-validator.cc b/src/shared-validator.cc
@@ -847,9 +847,9 @@ Result SharedValidator::OnCallIndirect(const Location& loc,
 Result SharedValidator::OnCallRef(const Location& loc, Var function_type_var) {
   Result result = CheckInstr(Opcode::CallRef, loc);
   FuncType func_type;
-  result |= typechecker_.OnCallRef(function_type_var.to_type());
   result |= CheckFuncTypeIndex(function_type_var, &func_type);
-  result |= typechecker_.OnCall(func_type.params, func_type.results);
+  result |= typechecker_.OnCallRef(function_type_var.to_type(),
+                                   func_type.params, func_type.results);
   return result;
 }
 
@@ -1214,9 +1214,9 @@ Result SharedValidator::OnReturnCallRef(const Location& loc,
                                         Var function_type_var) {
   Result result = CheckInstr(Opcode::ReturnCallRef, loc);
   FuncType func_type;
-  result |= typechecker_.OnReturnCallRef(function_type_var.to_type());
   result |= CheckFuncTypeIndex(function_type_var, &func_type);
-  result |= typechecker_.OnReturnCall(func_type.params, func_type.results);
+  result |= typechecker_.OnReturnCallRef(function_type_var.to_type(),
+                                         func_type.params, func_type.results);
   return result;
 }
 
diff --git a/src/type-checker.cc b/src/type-checker.cc
@@ -372,6 +372,17 @@ Result TypeChecker::PopAndCheckCall(const TypeVector& param_types,
   return result;
 }
 
+Result TypeChecker::PopAndCheckReturnCall(const TypeVector& result_types,
+                                          const char* desc) {
+  Label* func_label;
+  CHECK_RESULT(GetThisFunctionLabel(&func_label));
+  Result result =
+      CheckReturnSignature(result_types, func_label->result_types, desc);
+
+  CHECK_RESULT(SetUnreachable());
+  return result;
+}
+
 Result TypeChecker::PopAndCheck1Type(Type expected, const char* desc) {
   Result result = Result::Ok;
   result |= PeekAndCheckType(0, expected);
@@ -658,19 +669,18 @@ Result TypeChecker::OnCallIndirect(const TypeVector& param_types,
   return result;
 }
 
-Result TypeChecker::OnCallRef(Type type) {
-  return PopAndCheck1Type(type, "call_ref");
+Result TypeChecker::OnCallRef(Type type,
+                              const TypeVector& param_types,
+                              const TypeVector& result_types) {
+  Result result = PopAndCheck1Type(type, "call_ref");
+  result |= PopAndCheckCall(param_types, result_types, "call_ref");
+  return result;
 }
 
 Result TypeChecker::OnReturnCall(const TypeVector& param_types,
                                  const TypeVector& result_types) {
   Result result = PopAndCheckSignature(param_types, "return_call");
-  Label* func_label;
-  CHECK_RESULT(GetThisFunctionLabel(&func_label));
-  result |= CheckReturnSignature(result_types, func_label->result_types,
-                                 "return_call");
-
-  CHECK_RESULT(SetUnreachable());
+  result |= PopAndCheckReturnCall(result_types, "return_call");
   return result;
 }
 
@@ -679,17 +689,18 @@ Result TypeChecker::OnReturnCallIndirect(const TypeVector& param_types,
   Result result = PopAndCheck1Type(Type::I32, "return_call_indirect");
 
   result |= PopAndCheckSignature(param_types, "return_call_indirect");
-  Label* func_label;
-  CHECK_RESULT(GetThisFunctionLabel(&func_label));
-  result |= CheckReturnSignature(result_types, func_label->result_types,
-                                 "return_call_indirect");
-
-  CHECK_RESULT(SetUnreachable());
+  result |= PopAndCheckReturnCall(result_types, "return_call_indirect");
   return result;
 }
 
-Result TypeChecker::OnReturnCallRef(Type type) {
-  return PopAndCheck1Type(type, "return_call_ref");
+Result TypeChecker::OnReturnCallRef(Type type,
+                                    const TypeVector& param_types,
+                                    const TypeVector& result_types) {
+  Result result = PopAndCheck1Type(type, "return_call_ref");
+
+  result |= PopAndCheckSignature(param_types, "return_call_ref");
+  result |= PopAndCheckReturnCall(result_types, "return_call_ref");
+  return result;
 }
 
 Result TypeChecker::OnCompare(Opcode opcode) {
diff --git a/test/parse/bad-call-ref.txt b/test/parse/bad-call-ref.txt
@@ -0,0 +1,35 @@
+;;; TOOL: wat2wasm
+;;; ARGS: --enable-function-references
+;;; ERROR: 1
+(module
+  ;; Implicit type declarations are not allowed
+  (type $t0 (func (param f32 f32)))
+
+  (func $f1
+    i32.const 1
+    i32.const 2
+    i32.const 3
+    call_ref $t0
+  )
+
+  (func $f2
+    i32.const 1
+    i32.const 2
+    i32.const 3
+    return_call_ref $t0
+  )
+)
+(;; STDERR ;;;
+out/test/parse/bad-call-ref.txt:12:5: error: type mismatch in call_ref, expected [(ref null 0)] but got [... i32]
+    call_ref $t0
+    ^^^^^^^^
+out/test/parse/bad-call-ref.txt:12:5: error: type mismatch in call_ref, expected [f32, f32] but got [i32, i32]
+    call_ref $t0
+    ^^^^^^^^
+out/test/parse/bad-call-ref.txt:19:5: error: type mismatch in return_call_ref, expected [(ref null 0)] but got [... i32]
+    return_call_ref $t0
+    ^^^^^^^^^^^^^^^
+out/test/parse/bad-call-ref.txt:19:5: error: type mismatch in return_call_ref, expected [f32, f32] but got [i32, i32]
+    return_call_ref $t0
+    ^^^^^^^^^^^^^^^
+;;; STDERR ;;)
diff --git a/test/spec/function-references/call_ref.txt b/test/spec/function-references/call_ref.txt
@@ -7,7 +7,7 @@ out/test/spec/function-references/call_ref.wast:136: assert_trap passed: unreach
 out/test/spec/function-references/call_ref.wast:149: assert_trap passed: unreachable executed
 out/test/spec/function-references/call_ref.wast:165: assert_trap passed: unreachable executed
 out/test/spec/function-references/call_ref.wast:168: assert_invalid passed:
-  out/test/spec/function-references/call_ref/call_ref.4.wasm:0000042: error: type mismatch in call, expected [i32] but got [i64]
+  out/test/spec/function-references/call_ref/call_ref.4.wasm:0000042: error: type mismatch in call_ref, expected [i32] but got [i64]
   0000042: error: OnCallRefExpr callback failed
 out/test/spec/function-references/call_ref.wast:184: assert_invalid passed:
   out/test/spec/function-references/call_ref/call_ref.5.wasm:0000044: error: type mismatch in implicit return, expected [i32] but got [i64]
diff --git a/test/spec/function-references/return_call_ref.txt b/test/spec/function-references/return_call_ref.txt
@@ -26,7 +26,7 @@ out/test/spec/function-references/return_call_ref.wast:306: assert_trap passed:
 out/test/spec/function-references/return_call_ref.wast:319: assert_trap passed: unreachable executed
 out/test/spec/function-references/return_call_ref.wast:334: assert_trap passed: unreachable executed
 out/test/spec/function-references/return_call_ref.wast:337: assert_invalid passed:
-  out/test/spec/function-references/return_call_ref/return_call_ref.11.wasm:0000042: error: type mismatch in return_call, expected [i32] but got [i64]
+  out/test/spec/function-references/return_call_ref/return_call_ref.11.wasm:0000042: error: type mismatch in return_call_ref, expected [i32] but got [i64]
   0000042: error: OnReturnCallRefExpr callback failed
 out/test/spec/function-references/return_call_ref.wast:353: assert_invalid passed:
   out/test/spec/function-references/return_call_ref/return_call_ref.12.wasm:0000043: error: type mismatch in implicit return, expected [i32] but got [i64]
