Disallow exact references in public types (#7554)

When custom descriptors are disabled, validate that public types do not
contain exact references. If they did, we would drop the exactness and
change the identity of the public type during binary writing, which
would be incorrect. This still allows internal usage of exact types
without custom descriptors enabled, and it is up to the individual
passes to ensure that the eventual erasing of exactness does not cause
any problems.

Author: tlively

src/wasm/wasm-validator.cpp

@@ -3970,6 +3970,34 @@ static void validateBinaryenIR(Module& wasm, ValidationInfo& info) {
 
 // Main validator class
 
+static void validateTypes(Module& module, ValidationInfo& info) {
+  // Check that public types do not contain any exact references if custom
+  // descriptors is not enabled. If they did, we would erase the exactness
+  // during binary writing and change the public type identities.
+  if (module.features.hasCustomDescriptors()) {
+    return;
+  }
+
+  for (auto type : ModuleUtils::getPublicHeapTypes(module)) {
+    for (auto child : type.getTypeChildren()) {
+      if (child.isExact()) {
+        std::string typeName;
+        if (auto it = module.typeNames.find(type);
+            it != module.typeNames.end()) {
+          typeName = '$' + it->second.name.toString();
+        } else {
+          typeName = type.toString();
+        }
+        info.fail("Exact reference in public type not allowed without custom "
+                  "descriptors [--enable-custom-descriptors]",
+                  typeName,
+                  nullptr);
+        break;
+      }
+    }
+  }
+}
+
 static void validateImports(Module& module, ValidationInfo& info) {
   ModuleUtils::iterImportedFunctions(module, [&](Function* curr) {
     if (curr->getResults().isTuple()) {
@@ -4439,6 +4467,7 @@ bool WasmValidator::validate(Module& module, Flags flags) {
 
   // Validate globally.
   if (info.validateGlobally) {
+    validateTypes(module, info);
     validateImports(module, info);
     validateExports(module, info);
     validateGlobals(module, info);

test/lit/validation/public-exact.wast

@@ -0,0 +1,23 @@
+;; Test that exact references in public types are disallowed without custom descriptors
+
+;; RUN: not wasm-opt %s -all --disable-custom-descriptors 2>&1 | filecheck %s
+;; RUN: wasm-opt %s -all -S -o - | filecheck %s --check-prefix=NOERR
+
+;; CHECK:      [wasm-validator error in module] Exact reference in public type not allowed without custom descriptors [--enable-custom-descriptors], on
+;; CHECK-NEXT: $struct
+;; CHECK-NEXT: [wasm-validator error in module] Exact reference in public type not allowed without custom descriptors [--enable-custom-descriptors], on
+;; CHECK-NEXT: $array
+;; CHECK-NEXT: [wasm-validator error in module] Exact reference in public type not allowed without custom descriptors [--enable-custom-descriptors], on
+;; CHECK-NEXT: $func
+
+;; NOERR: (module
+
+(module
+  (type $struct (struct (field (ref null (exact $struct)))))
+  (type $array (array (field (ref (exact $struct)))))
+  (type $func (func (param (ref null (exact $struct))) (result (ref (exact $array)))))
+
+  (import "" "struct" (global $struct (ref $struct)))
+  (import "" "array" (global $array (ref $array)))
+  (import "" "func" (global $func (ref $func)))
+)