Revert exact reference types (#7402)

We decided that Custom Descriptors should introduce exact heap types
rather than exact reference types. Although these new features are very
similar, the APIs we need to change for them are completely different.

One option would have been to keep the existing exact reference type
implementation while additionally implementing exact heap types, but
there are not enough free bits in the type implementation to have both
at once without increasing the alignment of HeapTypeInfo allocations.
Portably increasing the alignment is annoying enough that it's easier to
just eagerly remove exact reference types to free up the bit for use
with exact heap types.

Fully or partially revert the following PRs:

 - #7371
 - #7365
 - #7360
 - #7357
 - #7356
 - #7355
 - #7354
 - #7353
 - #7347
 - #7342
 - #7328

Keep the new `.with(...)` Type APIs and the relevant parts of the type
relations gtest that were introduced as part of the reverted work.

Author: tlively

scripts/test/fuzzing.py

@@ -104,14 +104,6 @@
     'stack_switching_resume.wast',
     'stack_switching_resume_throw.wast',
     'stack_switching_switch.wast',
-    # TODO: fuzzer support for exact references
-    'exact-references.wast',
-    'optimize-instructions-exact.wast',
-    'local-subtyping-exact.wast',
-    'remove-unused-types-exact.wast',
-    'coalesce-locals-exact.wast',
-    'remove-unused-brs-exact.wast',
-    'exact.wast',
     # TODO: fuzzer support for custom descriptors
     'custom-descriptors.wast',
 ]

src/ir/manipulation.h

@@ -40,9 +40,10 @@ template<typename InputType> inline Nop* nop(InputType* target) {
 }
 
 template<typename InputType>
-inline RefNull* refNull(InputType* target, HeapType type) {
+inline RefNull* refNull(InputType* target, Type type) {
+  assert(type.isNullable() && type.getHeapType().isBottom());
   auto* ret = convert<InputType, RefNull>(target);
-  ret->finalize(Type(type.getBottom(), Nullable, Exact));
+  ret->finalize(type);
   return ret;
 }
 

src/ir/type-updating.cpp

@@ -342,7 +342,6 @@ Type GlobalTypeRewriter::getTempType(Type type) {
   if (type.isRef()) {
     auto heapType = type.getHeapType();
     if (auto it = typeIndices.find(heapType); it != typeIndices.end()) {
-      // TODO: Handle exactness.
       return typeBuilder.getTempRefType(typeBuilder[it->second],
                                         type.getNullability());
     }

src/ir/type-updating.h

@@ -497,7 +497,6 @@ class TypeMapper : public GlobalTypeRewriter {
     auto heapType = type.getHeapType();
     auto iter = mapping.find(heapType);
     if (iter != mapping.end()) {
-      // TODO: Handle exactness.
       return getTempType(Type(iter->second, type.getNullability()));
     }
     return getTempType(type);

src/literal.h

@@ -246,7 +246,7 @@ class Literal {
     }
   }
   static Literal makeNull(HeapType type) {
-    return Literal(Type(type.getBottom(), Nullable, Exact));
+    return Literal(Type(type.getBottom(), Nullable));
   }
   static Literal makeFunc(Name func, HeapType type) {
     return Literal(func, type);

src/parser/contexts.h

@@ -127,9 +127,7 @@ struct NullTypeParserCtx {
   TypeT makeF64() { return Ok{}; }
   TypeT makeV128() { return Ok{}; }
 
-  TypeT makeRefType(HeapTypeT, Nullability, Exactness) { return Ok{}; }
-
-  HeapTypeT getHeapTypeFromRefType(TypeT) { return Ok{}; }
+  TypeT makeRefType(HeapTypeT, Nullability) { return Ok{}; }
 
   TupleElemListT makeTupleElemList() { return Ok{}; }
   void appendTupleElem(TupleElemListT&, TypeT) {}
@@ -259,13 +257,10 @@ template<typename Ctx> struct TypeParserCtx {
   TypeT makeF64() { return Type::f64; }
   TypeT makeV128() { return Type::v128; }
 
-  TypeT
-  makeRefType(HeapTypeT ht, Nullability nullability, Exactness exactness) {
-    return Type(ht, nullability, exactness);
+  TypeT makeRefType(HeapTypeT ht, Nullability nullability) {
+    return Type(ht, nullability);
   }
 
-  HeapTypeT getHeapTypeFromRefType(TypeT t) { return t.getHeapType(); }
-
   std::vector<Type> makeTupleElemList() { return {}; }
   void appendTupleElem(std::vector<Type>& elems, Type elem) {
     elems.push_back(elem);
@@ -1122,13 +1117,10 @@ struct ParseTypeDefsCtx : TypeParserCtx<ParseTypeDefsCtx> {
     : TypeParserCtx<ParseTypeDefsCtx>(typeIndices), in(in), builder(builder),
       names(builder.size()) {}
 
-  TypeT
-  makeRefType(HeapTypeT ht, Nullability nullability, Exactness exactness) {
-    return builder.getTempRefType(ht, nullability, exactness);
+  TypeT makeRefType(HeapTypeT ht, Nullability nullability) {
+    return builder.getTempRefType(ht, nullability);
   }
 
-  HeapTypeT getHeapTypeFromRefType(TypeT t) { return t.getHeapType(); }
-
   TypeT makeTupleType(const std::vector<Type> types) {
     return builder.getTempTupleType(types);
   }

src/parser/parsers.h

@@ -30,8 +30,6 @@ using namespace std::string_view_literals;
 template<typename Ctx>
 Result<typename Ctx::HeapTypeT> absheaptype(Ctx&, Shareability);
 template<typename Ctx> Result<typename Ctx::HeapTypeT> heaptype(Ctx&);
-template<typename Ctx>
-MaybeResult<typename Ctx::TypeT> maybeReftypeAbbrev(Ctx&);
 template<typename Ctx> MaybeResult<typename Ctx::RefTypeT> maybeReftype(Ctx&);
 template<typename Ctx> Result<typename Ctx::RefTypeT> reftype(Ctx&);
 template<typename Ctx> MaybeResult<typename Ctx::TypeT> tupletype(Ctx&);
@@ -460,85 +458,68 @@ template<typename Ctx> Result<typename Ctx::HeapTypeT> heaptype(Ctx& ctx) {
 //           | 'i31ref'    => i31ref
 //           | 'structref' => structref
 //           | 'arrayref'  => arrayref
-//           | ...
-template<typename Ctx>
-MaybeResult<typename Ctx::TypeT> maybeReftypeAbbrev(Ctx& ctx) {
+//           | '(' ref null? t:heaptype ')' => ref null? t
+template<typename Ctx> MaybeResult<typename Ctx::TypeT> maybeReftype(Ctx& ctx) {
   if (ctx.in.takeKeyword("funcref"sv)) {
-    return ctx.makeRefType(ctx.makeFuncType(Unshared), Nullable, Inexact);
+    return ctx.makeRefType(ctx.makeFuncType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("externref"sv)) {
-    return ctx.makeRefType(ctx.makeExternType(Unshared), Nullable, Inexact);
+    return ctx.makeRefType(ctx.makeExternType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("anyref"sv)) {
-    return ctx.makeRefType(ctx.makeAnyType(Unshared), Nullable, Inexact);
+    return ctx.makeRefType(ctx.makeAnyType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("eqref"sv)) {
-    return ctx.makeRefType(ctx.makeEqType(Unshared), Nullable, Inexact);
+    return ctx.makeRefType(ctx.makeEqType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("i31ref"sv)) {
-    return ctx.makeRefType(ctx.makeI31Type(Unshared), Nullable, Inexact);
+    return ctx.makeRefType(ctx.makeI31Type(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("structref"sv)) {
-    return ctx.makeRefType(ctx.makeStructType(Unshared), Nullable, Inexact);
+    return ctx.makeRefType(ctx.makeStructType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("arrayref"sv)) {
-    return ctx.makeRefType(ctx.makeArrayType(Unshared), Nullable, Inexact);
+    return ctx.makeRefType(ctx.makeArrayType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("exnref"sv)) {
-    return ctx.makeRefType(ctx.makeExnType(Unshared), Nullable, Inexact);
+    return ctx.makeRefType(ctx.makeExnType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("stringref"sv)) {
-    return ctx.makeRefType(ctx.makeStringType(Unshared), Nullable, Inexact);
+    return ctx.makeRefType(ctx.makeStringType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("contref"sv)) {
-    return ctx.makeRefType(ctx.makeContType(Unshared), Nullable, Inexact);
+    return ctx.makeRefType(ctx.makeContType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("nullref"sv)) {
-    return ctx.makeRefType(ctx.makeNoneType(Unshared), Nullable, Inexact);
+    return ctx.makeRefType(ctx.makeNoneType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("nullexternref"sv)) {
-    return ctx.makeRefType(ctx.makeNoextType(Unshared), Nullable, Inexact);
+    return ctx.makeRefType(ctx.makeNoextType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("nullfuncref"sv)) {
-    return ctx.makeRefType(ctx.makeNofuncType(Unshared), Nullable, Inexact);
+    return ctx.makeRefType(ctx.makeNofuncType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("nullexnref"sv)) {
-    return ctx.makeRefType(ctx.makeNoexnType(Unshared), Nullable, Inexact);
+    return ctx.makeRefType(ctx.makeNoexnType(Unshared), Nullable);
   }
   if (ctx.in.takeKeyword("nullcontref"sv)) {
-    return ctx.makeRefType(ctx.makeNocontType(Unshared), Nullable, Inexact);
+    return ctx.makeRefType(ctx.makeNocontType(Unshared), Nullable);
   }
-  return {};
-}
 
-// reftype ::= ...
-//           | '(' 'exact' (ref null ht):shorthand ')' => ref null exact ht
-//           | '(' ref null? exact? ht:heaptype ')' => ref null? t
-template<typename Ctx> MaybeResult<typename Ctx::TypeT> maybeReftype(Ctx& ctx) {
-  if (ctx.in.takeSExprStart("exact"sv)) {
-    auto rt = maybeReftypeAbbrev(ctx);
-    CHECK_ERR(rt);
-    if (!rt) {
-      return ctx.in.err("expected reftype shorthand");
-    }
-    if (!ctx.in.takeRParen()) {
-      return ctx.in.err("expected end of reftype");
-    }
-    return ctx.makeRefType(ctx.getHeapTypeFromRefType(*rt), Nullable, Exact);
+  if (!ctx.in.takeSExprStart("ref"sv)) {
+    return {};
   }
 
-  if (ctx.in.takeSExprStart("ref"sv)) {
-    auto nullability = ctx.in.takeKeyword("null"sv) ? Nullable : NonNullable;
-    auto exactness = ctx.in.takeKeyword("exact"sv) ? Exact : Inexact;
-    auto type = heaptype(ctx);
-    CHECK_ERR(type);
-    if (!ctx.in.takeRParen()) {
-      return ctx.in.err("expected end of reftype");
-    }
-    return ctx.makeRefType(*type, nullability, exactness);
+  auto nullability = ctx.in.takeKeyword("null"sv) ? Nullable : NonNullable;
+
+  auto type = heaptype(ctx);
+  CHECK_ERR(type);
+
+  if (!ctx.in.takeRParen()) {
+    return ctx.in.err("expected end of reftype");
   }
 
-  return maybeReftypeAbbrev(ctx);
+  return ctx.makeRefType(*type, nullability);
 }
 
 template<typename Ctx> Result<typename Ctx::TypeT> reftype(Ctx& ctx) {

src/passes/OptimizeInstructions.cpp

@@ -2277,14 +2277,10 @@ struct OptimizeInstructions
           // emit a null check.
           bool needsNullCheck = ref->type.getNullability() == Nullable &&
                                 curr->type.getNullability() == NonNullable;
-          // Same with exactness.
-          bool needsExactCast = ref->type.getExactness() == Inexact &&
-                                curr->type.getExactness() == Exact;
           // If the best value to propagate is the argument to the cast, we can
           // simply remove the cast (or downgrade it to a null check if
-          // necessary). This does not work if we need a cast to prove
-          // exactness.
-          if (ref == curr->ref && !needsExactCast) {
+          // necessary).
+          if (ref == curr->ref) {
             if (needsNullCheck) {
               replaceCurrent(builder.makeRefAs(RefAsNonNull, curr->ref));
             } else {
@@ -2293,17 +2289,17 @@ struct OptimizeInstructions
             return;
           }
           // Otherwise we can't just remove the cast and replace it with `ref`
-          // because the intermediate expressions might have had side effects or
-          // we need to check exactness. We can replace the cast with a drop
-          // followed by a direct return of the value, though.
+          // because the intermediate expressions might have had side effects.
+          // We can replace the cast with a drop followed by a direct return of
+          // the value, though.
           if (ref->type.isNull()) {
             // We can materialize the resulting null value directly.
             //
             // The type must be nullable for us to do that, which it normally
             // would be, aside from the interesting corner case of
             // uninhabitable types:
             //
-            //  (ref.cast (ref func)
+            //  (ref.cast func
             //    (block (result (ref nofunc))
             //      (unreachable)
             //    )
@@ -2350,20 +2346,18 @@ struct OptimizeInstructions
       }
         [[fallthrough]];
       case GCTypeUtils::SuccessOnlyIfNull: {
+        auto nullType = Type(curr->type.getHeapType().getBottom(), Nullable);
         // The cast either returns null or traps. In trapsNeverHappen mode
         // we know the result, since by assumption it will not trap.
         if (getPassOptions().trapsNeverHappen) {
-          replaceCurrent(
-            builder.makeBlock({builder.makeDrop(curr->ref),
-                               builder.makeRefNull(curr->type.getHeapType())},
-                              curr->type));
+          replaceCurrent(builder.makeBlock(
+            {builder.makeDrop(curr->ref), builder.makeRefNull(nullType)},
+            curr->type));
           return;
         }
         // Otherwise, we should have already refined the cast type to cast
-        // directly to null. We do not further refine the cast type to exact
-        // null because the extra precision is not useful and doing so would
-        // increase the size of the instruction encoding.
-        assert(curr->type.isNull());
+        // directly to null.
+        assert(curr->type == nullType);
         break;
       }
       case GCTypeUtils::Unreachable:

src/passes/RemoveUnusedBrs.cpp

@@ -859,8 +859,8 @@ struct RemoveUnusedBrs : public WalkerPass<PostWalker<RemoveUnusedBrs>> {
           if (Type::isSubType(expr->type, type)) {
             return expr;
           }
-          if (type.isNonNullable() && expr->type.isNullable() &&
-              Type::isSubType(expr->type.with(NonNullable), type)) {
+          if (HeapType::isSubType(expr->type.getHeapType(),
+                                  type.getHeapType())) {
             return builder.makeRefAs(RefAsNonNull, expr);
           }
           return builder.makeRefCast(expr, type);

src/tools/fuzzing.h

@@ -360,10 +360,6 @@ class TranslateToFuzzReader {
   // instruction for EH is supposed to exist only at the beginning of a 'catch'
   // block, so it shouldn't be moved around or deleted freely.
   bool canBeArbitrarilyReplaced(Expression* curr) {
-    // TODO: Remove this once we better support exact references.
-    if (curr->type.isExact()) {
-      return false;
-    }
     return curr->type.isDefaultable() &&
            !EHUtils::containsValidDanglingPop(curr);
   }
@@ -525,9 +521,7 @@ class TranslateToFuzzReader {
   Type getLoggableType();
   bool isLoggableType(Type type);
   Nullability getNullability();
-  Exactness getExactness();
   Nullability getSubType(Nullability nullability);
-  Exactness getSubType(Exactness exactness);
   HeapType getSubType(HeapType type);
   Type getSubType(Type type);
   Nullability getSuperType(Nullability nullability);