Update exact reference semantics

src/wasm-builder.h

@@ -673,12 +673,6 @@ class Builder {
     ret->finalize(Type(type.getBottom(), Nullable));
     return ret;
   }
-  RefNull* makeRefNull(Type type) {
-    assert(type.isNullable() && type.isNull() && type.isExact());
-    auto* ret = wasm.allocator.alloc<RefNull>();
-    ret->finalize(type);
-    return ret;
-  }
   RefIsNull* makeRefIsNull(Expression* value) {
     auto* ret = wasm.allocator.alloc<RefIsNull>();
     ret->value = value;

src/wasm-type.h

@@ -323,6 +323,7 @@ class Type {
     : Type(heapType.getID() | (nullable == Nullable ? NullMask : 0) |
            (exact == Exact ? ExactMask : 0)) {
     assert(!(heapType.getID() & (TupleMask | NullMask | ExactMask)));
+    assert(!heapType.isBasic() || exact == Inexact);
   }
 
   // Predicates

src/wasm/wasm-type.cpp

@@ -795,13 +795,14 @@ Type Type::getLeastUpperBound(Type a, Type b) {
     if (auto heapType = HeapType::getLeastUpperBound(heapTypeA, heapTypeB)) {
       auto nullability =
         (a.isNullable() || b.isNullable()) ? Nullable : NonNullable;
-      auto exactness = (a.isInexact() || b.isInexact()) ? Inexact : Exact;
-      // The LUB can only be exact if the heap types are the same or one of them
-      // is bottom.
-      if (heapTypeA != heapTypeB && !heapTypeA.isBottom() &&
-          !heapTypeB.isBottom()) {
-        exactness = Inexact;
-      }
+      // If one heap type is bottom, then the exactness comes from the other
+      // heap type. Otherwise, the LUB can only be exact if both of the inputs
+      // are the same exact heap type.
+      auto exactness = heapTypeA.isBottom()               ? b.getExactness()
+                       : heapTypeB.isBottom()             ? a.getExactness()
+                       : (a.isInexact() || b.isInexact()) ? Inexact
+                       : (heapTypeA != heapTypeB)         ? Inexact
+                                                          : Exact;
       return Type(*heapType, nullability, exactness);
     }
   }
@@ -850,6 +851,7 @@ Type Type::getGreatestLowerBound(Type a, Type b) {
   if ((a.isExact() && heapType != heapA) ||
       (b.isExact() && heapType != heapB)) {
     heapType = heapA.getBottom();
+    exactness = Inexact;
   }
   return Type(heapType, nullability, exactness);
 }
@@ -1515,13 +1517,15 @@ bool SubTyper::isSubType(Type a, Type b) {
   if (a.isNullable() && !b.isNullable()) {
     return false;
   }
-  if (a.isInexact() && !b.isInexact()) {
-    return false;
-  }
   auto heapTypeA = a.getHeapType();
   auto heapTypeB = b.getHeapType();
-  if (b.isExact() && !heapTypeA.isBottom()) {
-    return heapTypeA == heapTypeB;
+  if (b.isExact()) {
+    if (a.isExact()) {
+      return heapTypeA == heapTypeB;
+    }
+    if (!heapTypeA.isBottom()) {
+      return false;
+    }
   }
   return isSubType(heapTypeA, heapTypeB);
 }

src/wasm/wasm.cpp

@@ -800,7 +800,7 @@ void MemoryGrow::finalize() {
 
 void RefNull::finalize(HeapType heapType) {
   assert(heapType.isBottom());
-  type = Type(heapType, Nullable, Exact);
+  type = Type(heapType, Nullable);
 }
 
 void RefNull::finalize(Type type_) { type = type_; }