Fuzzing stubs for defined types.

Author: dhil

test/gtest/type-domains.cpp

@@ -496,6 +496,10 @@ fuzztest::Domain<HeapTypePlan> AvailableStrictSubHeapType(TypeBuilderPlan plan,
         return matchingOrAbstract(
           [](auto kind) { return kind == ContKind; },
           fuzztest::Just(HeapType(HeapTypes::nocont.getBasic(share))));
+      case HeapType::handler:
+        return matchingOrAbstract(
+          [](auto kind) { return kind == HandlerKind; },
+          fuzztest::Just(HeapType(HeapTypes::nocont.getBasic(share))));
       case HeapType::any:
         return matchingOrAbstract(
           [](auto kind) { return kind == StructKind || kind == ArrayKind; },
@@ -532,6 +536,7 @@ fuzztest::Domain<HeapTypePlan> AvailableStrictSubHeapType(TypeBuilderPlan plan,
       case HeapType::nofunc:
       case HeapType::nocont:
       case HeapType::noexn:
+      case HeapType::nohandler:
         // No strict subtypes, so just return super.
         return fuzztest::Just(super);
     }
@@ -586,6 +591,7 @@ AvailableStrictSuperHeapType(TypeBuilderPlan plan, HeapTypePlan sub) {
       case HeapType::cont:
       case HeapType::any:
       case HeapType::exn:
+      case HeapType::handler:
         // No strict supertypes, so just return sub.
         return fuzztest::Just(sub);
       case HeapType::eq:
@@ -617,6 +623,10 @@ AvailableStrictSuperHeapType(TypeBuilderPlan plan, HeapTypePlan sub) {
         return matchingOrAbstract(
           [](auto kind) { return kind == ContKind; },
           fuzztest::Just(HeapType(HeapTypes::cont.getBasic(share))));
+      case HeapType::nohandler:
+        return matchingOrAbstract(
+          [](auto kind) { return kind == HandlerKind; },
+          fuzztest::Just(HeapType(HeapTypes::handler.getBasic(share))));
       case HeapType::noexn:
         return fuzztest::Just(
           HeapTypePlan{HeapType(HeapTypes::exn.getBasic(share))});
@@ -1134,6 +1144,15 @@ void TestBuiltTypes(std::pair<std::vector<HeapType>, TypeBuilderPlan> pair) {
     }
   };
 
+  auto checkHandler = [&](HandlerPlan& plan, HeapType type) {
+    ASSERT_TRUE(type.isHandler());
+    auto value_types = type.getHandler().value_types;
+    ASSERT_EQ(plan.size(), value_types.size());
+    for (size_t i = 0; i < plan.size(); ++i) {
+      checkType(plan[i], value_types[i]);
+    }
+  };
+
   auto checkDef = [&](TypeDefPlan& plan, HeapType type) {
     if (auto* f = plan.getFunc()) {
       checkFunc(*f, type);
@@ -1143,6 +1162,8 @@ void TestBuiltTypes(std::pair<std::vector<HeapType>, TypeBuilderPlan> pair) {
       checkArray(*a, type);
     } else if (auto* c = plan.getCont()) {
       checkCont(*c, type);
+    } else if (auto* h = plan.getHandler()) {
+      checkCont(*h, type);
     } else {
       WASM_UNREACHABLE("unexpected variant");
     }

test/gtest/type-domains.h

@@ -31,6 +31,7 @@ inline fuzztest::Domain<HeapType> ArbitraryUnsharedAbstractHeapType() {
     HeapTypes::ext,
     HeapTypes::func,
     HeapTypes::cont,
+    HeapTypes::handler,
     HeapTypes::any,
     HeapTypes::eq,
     HeapTypes::i31,
@@ -43,6 +44,7 @@ inline fuzztest::Domain<HeapType> ArbitraryUnsharedAbstractHeapType() {
     HeapTypes::nofunc,
     HeapTypes::nocont,
     HeapTypes::noexn,
+    HeapTypes::nohandler,
   });
 }
 
@@ -67,7 +69,13 @@ inline fuzztest::Domain<Type> ArbitraryNonRefType() {
     std::vector<Type>{Type::i32, Type::i64, Type::f32, Type::f64, Type::v128});
 }
 
-enum UnsharedTypeKind { FuncKind, StructKind, ArrayKind, ContKind };
+enum UnsharedTypeKind {
+  FuncKind,
+  StructKind,
+  ArrayKind,
+  ContKind,
+  HandlerKind
+};
 
 struct TypeKind {
   UnsharedTypeKind kind;
@@ -108,12 +116,15 @@ using ArrayPlan = FieldPlan;
 // If there is no available func type definition, this will be nullopt and we
 // will have to use a default fallback.
 using ContPlan = std::optional<size_t>;
+using HandlerPlan = std::vector<TypePlan>;
 
-struct TypeDefPlan : std::variant<FuncPlan, StructPlan, ArrayPlan, ContPlan> {
+struct TypeDefPlan
+  : std::variant<FuncPlan, StructPlan, ArrayPlan, ContPlan, HandlerPlan> {
   FuncPlan* getFunc() { return std::get_if<FuncPlan>(this); }
   StructPlan* getStruct() { return std::get_if<StructPlan>(this); }
   ArrayPlan* getArray() { return std::get_if<ArrayPlan>(this); }
   ContPlan* getCont() { return std::get_if<ContPlan>(this); }
+  HandlerPlan* getHandler() { return std::get_if<HandlerPlan>(this); }
 };
 
 struct TypeBuilderPlan {