Validation fixes

src/parser/parsers.h

@@ -357,7 +357,7 @@ Result<std::vector<Name>> inlineExports(Lexer&);
 template<typename Ctx> Result<> comptype(Ctx&);
 template<typename Ctx> Result<> sharecomptype(Ctx&);
 template<typename Ctx> Result<> subtype(Ctx&);
-template<typename Ctx> MaybeResult<> typedef_(Ctx&, bool inRecGroup);
+template<typename Ctx> MaybeResult<> typedef_(Ctx&);
 template<typename Ctx> MaybeResult<> rectype(Ctx&);
 template<typename Ctx> MaybeResult<typename Ctx::LocalsT> locals(Ctx&);
 template<typename Ctx> MaybeResult<> import_(Ctx&);
@@ -2983,7 +2983,7 @@ template<typename Ctx> Result<> subtype(Ctx& ctx) {
 // typedef ::= '(' 'type' id? ('(' 'export' name ')')* subtype ')'
 //           | '(' 'type' id? ('(' 'export' name ')')*
 //                 '(' 'import' mod:name nm:name ')' typetype ')'
-template<typename Ctx> MaybeResult<> typedef_(Ctx& ctx, bool inRecGroup) {
+template<typename Ctx> MaybeResult<> typedef_(Ctx& ctx) {
   auto pos = ctx.in.getPos();
 
   if (!ctx.in.takeSExprStart("type"sv)) {
@@ -3002,9 +3002,6 @@ template<typename Ctx> MaybeResult<> typedef_(Ctx& ctx, bool inRecGroup) {
   CHECK_ERR(import);
 
   if (import) {
-    if (inRecGroup) {
-      return ctx.in.err("type import not allowed in recursive group");
-    }
     auto typePos = ctx.in.getPos();
     auto type = typetype(ctx);
     CHECK_ERR(type);
@@ -3030,15 +3027,15 @@ template<typename Ctx> MaybeResult<> rectype(Ctx& ctx) {
   if (ctx.in.takeSExprStart("rec"sv)) {
     size_t startIndex = ctx.getRecGroupStartIndex();
     size_t groupLen = 0;
-    while (auto type = typedef_(ctx, true)) {
+    while (auto type = typedef_(ctx)) {
       CHECK_ERR(type);
       ++groupLen;
     }
     if (!ctx.in.takeRParen()) {
       return ctx.in.err("expected type definition or end of recursion group");
     }
     ctx.addRecGroup(startIndex, groupLen);
-  } else if (auto type = typedef_(ctx, false)) {
+  } else if (auto type = typedef_(ctx)) {
     CHECK_ERR(type);
   } else {
     return {};

src/wasm-type.h

@@ -800,6 +800,8 @@ struct TypeBuilder {
     InvalidFuncType,
     // A type import has an invalid bound.
     InvalidBoundType,
+    // Type import in recursive group
+    ImportInRecGroup,
     // A non-shared field of a shared heap type.
     InvalidUnsharedField,
   };

src/wasm/wasm-type.cpp

@@ -1441,6 +1441,8 @@ std::ostream& operator<<(std::ostream& os, TypeBuilder::ErrorReason reason) {
       return os << "Continuation has invalid function type";
     case TypeBuilder::ErrorReason::InvalidBoundType:
       return os << "Type import has invalid bound type";
+    case TypeBuilder::ErrorReason::ImportInRecGroup:
+      return os << "Type import in recursive group";
     case TypeBuilder::ErrorReason::InvalidUnsharedField:
       return os << "Heap type has an invalid unshared field";
   }
@@ -2316,14 +2318,17 @@ bool isValidSupertype(const HeapTypeInfo& sub, const HeapTypeInfo& super) {
     case HeapTypeKind::Array:
       return typer.isSubType(sub.array, super.array);
     case HeapTypeKind::Import:
+      return false;
     case HeapTypeKind::Basic:
       break;
   }
   WASM_UNREACHABLE("unknown kind");
 }
 
 std::optional<TypeBuilder::ErrorReason>
-validateType(HeapTypeInfo& info, std::unordered_set<HeapType>& seenTypes) {
+validateType(HeapTypeInfo& info,
+             std::unordered_set<HeapType>& seenTypes,
+             bool inRecGroup) {
   if (auto* super = info.supertype) {
     // The supertype must be canonical (i.e. defined in a previous rec group)
     // or have already been defined in this rec group.
@@ -2340,6 +2345,14 @@ validateType(HeapTypeInfo& info, std::unordered_set<HeapType>& seenTypes) {
       return TypeBuilder::ErrorReason::InvalidFuncType;
     }
   }
+  if (info.isImport()) {
+    if (!info.import.bound.isBasic()) {
+      return TypeBuilder::ErrorReason::InvalidBoundType;
+    }
+    if (inRecGroup) {
+      return TypeBuilder::ErrorReason::ImportInRecGroup;
+    }
+  }
   if (info.share == Shared) {
     switch (info.kind) {
       case HeapTypeKind::Func:
@@ -2365,9 +2378,8 @@ validateType(HeapTypeInfo& info, std::unordered_set<HeapType>& seenTypes) {
         break;
       }
       case HeapTypeKind::Import:
-        if (!info.import.bound.isShared()) {
-          return TypeBuilder::ErrorReason::InvalidBoundType;
-        }
+        // The sharedness is inherited (see buildRecGroup below).
+        assert(info.import.bound.isShared());
         break;
       case HeapTypeKind::Basic:
         WASM_UNREACHABLE("unexpected kind");
@@ -2440,7 +2452,11 @@ buildRecGroup(std::unique_ptr<RecGroupInfo>&& groupInfo,
   std::unordered_set<HeapType> seenTypes;
   for (size_t i = 0; i < typeInfos.size(); ++i) {
     auto& info = typeInfos[i];
-    if (auto err = validateType(*info, seenTypes)) {
+    if (info->isImport()) {
+      // Sharedness is inherited from the bound
+      info->share = info->import.bound.getShared();
+    }
+    if (auto err = validateType(*info, seenTypes, typeInfos.size() > 1)) {
       return {TypeBuilder::Error{i, *err}};
     }
     seenTypes.insert(asHeapType(info));