Type RefNull as inexact

In preparation for disallowing inexact references to abstract heap
types, which are no longer allowed by the Custom Descriptors proposal.

src/ir/manipulation.h

@@ -42,7 +42,7 @@ template<typename InputType> inline Nop* nop(InputType* target) {
 template<typename InputType>
 inline RefNull* refNull(InputType* target, HeapType type) {
   auto* ret = convert<InputType, RefNull>(target);
-  ret->finalize(Type(type.getBottom(), Nullable, Exact));
+  ret->finalize(Type(type.getBottom(), Nullable));
   return ret;
 }
 

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/wasm-builder.h

@@ -670,7 +670,7 @@ class Builder {
   }
   RefNull* makeRefNull(HeapType type) {
     auto* ret = wasm.allocator.alloc<RefNull>();
-    ret->finalize(Type(type.getBottom(), Nullable, Exact));
+    ret->finalize(Type(type.getBottom(), Nullable));
     return ret;
   }
   RefNull* makeRefNull(Type type) {

src/wasm/wasm-validator.cpp

@@ -2288,10 +2288,6 @@ void FunctionValidator::visitRefNull(RefNull* curr) {
         curr->type.isNullable(), curr, "ref.null types must be nullable")) {
     return;
   }
-  if (!shouldBeTrue(
-        curr->type.isExact(), curr, "ref.null types must be exact")) {
-    return;
-  }
   shouldBeTrue(
     curr->type.isNull(), curr, "ref.null must have a bottom heap type");
 }

test/lit/basic/reference-types.wast

@@ -961,7 +961,7 @@
   ;; CHECK-BIN-NEXT:  )
   ;; CHECK-BIN-NEXT:  (drop
   ;; CHECK-BIN-NEXT:   (block $block2 (result eqref)
-  ;; CHECK-BIN-NEXT:    (ref.cast (exact nullref)
+  ;; CHECK-BIN-NEXT:    (ref.cast nullref
   ;; CHECK-BIN-NEXT:     (br_if $block2
   ;; CHECK-BIN-NEXT:      (ref.null none)
   ;; CHECK-BIN-NEXT:      (i32.const 1)
@@ -987,7 +987,7 @@
   ;; CHECK-BIN-NEXT:  )
   ;; CHECK-BIN-NEXT:  (drop
   ;; CHECK-BIN-NEXT:   (block $block5 (result funcref)
-  ;; CHECK-BIN-NEXT:    (ref.cast (exact nullfuncref)
+  ;; CHECK-BIN-NEXT:    (ref.cast nullfuncref
   ;; CHECK-BIN-NEXT:     (br_if $block5
   ;; CHECK-BIN-NEXT:      (ref.null nofunc)
   ;; CHECK-BIN-NEXT:      (i32.const 1)
@@ -1023,7 +1023,7 @@
   ;; CHECK-BIN-NEXT:  )
   ;; CHECK-BIN-NEXT:  (drop
   ;; CHECK-BIN-NEXT:   (block $block9 (result anyref)
-  ;; CHECK-BIN-NEXT:    (ref.cast (exact nullref)
+  ;; CHECK-BIN-NEXT:    (ref.cast nullref
   ;; CHECK-BIN-NEXT:     (br_if $block9
   ;; CHECK-BIN-NEXT:      (ref.null none)
   ;; CHECK-BIN-NEXT:      (i32.const 1)
@@ -1043,7 +1043,7 @@
   ;; CHECK-BIN-NEXT:  )
   ;; CHECK-BIN-NEXT:  (drop
   ;; CHECK-BIN-NEXT:   (block $block11 (result anyref)
-  ;; CHECK-BIN-NEXT:    (ref.cast (exact nullref)
+  ;; CHECK-BIN-NEXT:    (ref.cast nullref
   ;; CHECK-BIN-NEXT:     (br_if $block11
   ;; CHECK-BIN-NEXT:      (ref.null none)
   ;; CHECK-BIN-NEXT:      (i32.const 1)
@@ -2298,7 +2298,7 @@
 ;; CHECK-BIN-NODEBUG-NEXT:  )
 ;; CHECK-BIN-NODEBUG-NEXT:  (drop
 ;; CHECK-BIN-NODEBUG-NEXT:   (block $block2 (result eqref)
-;; CHECK-BIN-NODEBUG-NEXT:    (ref.cast (exact nullref)
+;; CHECK-BIN-NODEBUG-NEXT:    (ref.cast nullref
 ;; CHECK-BIN-NODEBUG-NEXT:     (br_if $block2
 ;; CHECK-BIN-NODEBUG-NEXT:      (ref.null none)
 ;; CHECK-BIN-NODEBUG-NEXT:      (i32.const 1)
@@ -2324,7 +2324,7 @@
 ;; CHECK-BIN-NODEBUG-NEXT:  )
 ;; CHECK-BIN-NODEBUG-NEXT:  (drop
 ;; CHECK-BIN-NODEBUG-NEXT:   (block $block5 (result funcref)
-;; CHECK-BIN-NODEBUG-NEXT:    (ref.cast (exact nullfuncref)
+;; CHECK-BIN-NODEBUG-NEXT:    (ref.cast nullfuncref
 ;; CHECK-BIN-NODEBUG-NEXT:     (br_if $block5
 ;; CHECK-BIN-NODEBUG-NEXT:      (ref.null nofunc)
 ;; CHECK-BIN-NODEBUG-NEXT:      (i32.const 1)
@@ -2360,7 +2360,7 @@
 ;; CHECK-BIN-NODEBUG-NEXT:  )
 ;; CHECK-BIN-NODEBUG-NEXT:  (drop
 ;; CHECK-BIN-NODEBUG-NEXT:   (block $block9 (result anyref)
-;; CHECK-BIN-NODEBUG-NEXT:    (ref.cast (exact nullref)
+;; CHECK-BIN-NODEBUG-NEXT:    (ref.cast nullref
 ;; CHECK-BIN-NODEBUG-NEXT:     (br_if $block9
 ;; CHECK-BIN-NODEBUG-NEXT:      (ref.null none)
 ;; CHECK-BIN-NODEBUG-NEXT:      (i32.const 1)
@@ -2380,7 +2380,7 @@
 ;; CHECK-BIN-NODEBUG-NEXT:  )
 ;; CHECK-BIN-NODEBUG-NEXT:  (drop
 ;; CHECK-BIN-NODEBUG-NEXT:   (block $block11 (result anyref)
-;; CHECK-BIN-NODEBUG-NEXT:    (ref.cast (exact nullref)
+;; CHECK-BIN-NODEBUG-NEXT:    (ref.cast nullref
 ;; CHECK-BIN-NODEBUG-NEXT:     (br_if $block11
 ;; CHECK-BIN-NODEBUG-NEXT:      (ref.null none)
 ;; CHECK-BIN-NODEBUG-NEXT:      (i32.const 1)

test/lit/heap-types.wast

@@ -12,7 +12,7 @@
   (type $struct.B (struct i32))
   ;; CHECK:      (func $test (type $0)
   ;; CHECK-NEXT:  (drop
-  ;; CHECK-NEXT:   (ref.test (ref exact none)
+  ;; CHECK-NEXT:   (ref.test (ref none)
   ;; CHECK-NEXT:    (ref.null none)
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
@@ -29,7 +29,7 @@
   (type $struct.B (struct i32))
   ;; CHECK:      (func $test (type $0)
   ;; CHECK-NEXT:  (drop
-  ;; CHECK-NEXT:   (ref.cast (exact nullref)
+  ;; CHECK-NEXT:   (ref.cast nullref
   ;; CHECK-NEXT:    (ref.null none)
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )

test/lit/passes/cfp.wast

@@ -1034,7 +1034,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
-  ;; CHECK-NEXT:   (block (result (exact nullref))
+  ;; CHECK-NEXT:   (block (result nullref)
   ;; CHECK-NEXT:    (drop
   ;; CHECK-NEXT:     (ref.as_non_null
   ;; CHECK-NEXT:      (local.get $struct3)
@@ -1233,7 +1233,7 @@
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
-  ;; CHECK-NEXT:   (block (result (exact nullref))
+  ;; CHECK-NEXT:   (block (result nullref)
   ;; CHECK-NEXT:    (drop
   ;; CHECK-NEXT:     (ref.as_non_null
   ;; CHECK-NEXT:      (local.get $struct3)

test/lit/passes/code-pushing-gc.wast

@@ -7,7 +7,7 @@
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (block $out (result (ref func))
   ;; CHECK-NEXT:    (drop
-  ;; CHECK-NEXT:     (br_on_cast $out (exact nullfuncref) (ref exact nofunc)
+  ;; CHECK-NEXT:     (br_on_cast $out nullfuncref (ref nofunc)
   ;; CHECK-NEXT:      (ref.null nofunc)
   ;; CHECK-NEXT:     )
   ;; CHECK-NEXT:    )
@@ -48,7 +48,7 @@
   ;; CHECK-NEXT:     (ref.func $br_on_no)
   ;; CHECK-NEXT:    )
   ;; CHECK-NEXT:    (drop
-  ;; CHECK-NEXT:     (br_on_cast $out (exact nullfuncref) (ref exact nofunc)
+  ;; CHECK-NEXT:     (br_on_cast $out nullfuncref (ref nofunc)
   ;; CHECK-NEXT:      (ref.null nofunc)
   ;; CHECK-NEXT:     )
   ;; CHECK-NEXT:    )

test/lit/passes/dae-gc-refine-params.wast

@@ -262,7 +262,7 @@
  )
  ;; This function is called in ways that allow us to make the first parameter
  ;; non-nullable.
- ;; CHECK:      (func $various-params-null (type $13) (param $x (ref exact none)) (param $y (ref null $"{i32}"))
+ ;; CHECK:      (func $various-params-null (type $13) (param $x (ref none)) (param $y (ref null $"{i32}"))
  ;; CHECK-NEXT:  (local $temp i32)
  ;; CHECK-NEXT:  (drop
  ;; CHECK-NEXT:   (local.get $x)

test/lit/passes/dae-gc.wast

@@ -110,7 +110,7 @@
  )
 
  ;; CHECK:      (func $bar (type $2) (param $0 i31ref)
- ;; CHECK-NEXT:  (local $1 (exact nullref))
+ ;; CHECK-NEXT:  (local $1 nullref)
  ;; CHECK-NEXT:  (local.set $1
  ;; CHECK-NEXT:   (ref.null none)
  ;; CHECK-NEXT:  )

test/lit/passes/flatten_all-features.wast

@@ -3581,8 +3581,8 @@
   ;; CHECK:      (func $subtype (type $7) (result anyref)
   ;; CHECK-NEXT:  (local $0 eqref)
   ;; CHECK-NEXT:  (local $1 anyref)
-  ;; CHECK-NEXT:  (local $2 (exact nullref))
-  ;; CHECK-NEXT:  (local $3 (exact nullref))
+  ;; CHECK-NEXT:  (local $2 nullref)
+  ;; CHECK-NEXT:  (local $3 nullref)
   ;; CHECK-NEXT:  (local $4 eqref)
   ;; CHECK-NEXT:  (local $5 eqref)
   ;; CHECK-NEXT:  (local $6 eqref)
@@ -3680,7 +3680,7 @@
  ;; CHECK:      (type $0 (func (result funcref)))
 
  ;; CHECK:      (func $0 (type $0) (result funcref)
- ;; CHECK-NEXT:  (local $0 (ref exact nofunc))
+ ;; CHECK-NEXT:  (local $0 (ref nofunc))
  ;; CHECK-NEXT:  (local.set $0
  ;; CHECK-NEXT:   (ref.as_non_null
  ;; CHECK-NEXT:    (ref.null nofunc)

test/lit/passes/global-refining.wast

@@ -11,8 +11,8 @@
   ;; CLOSD:      (type $foo_t (func))
   (type $foo_t (func))
 
-  ;; CHECK:      (global $func-null-init (mut (exact nullfuncref)) (ref.null nofunc))
-  ;; CLOSD:      (global $func-null-init (mut (exact nullfuncref)) (ref.null nofunc))
+  ;; CHECK:      (global $func-null-init (mut nullfuncref) (ref.null nofunc))
+  ;; CLOSD:      (global $func-null-init (mut nullfuncref) (ref.null nofunc))
   (global $func-null-init (mut funcref) (ref.null $foo_t))
   ;; CHECK:      (global $func-func-init (mut (ref $foo_t)) (ref.func $foo))
   ;; CLOSD:      (global $func-func-init (mut (ref $foo_t)) (ref.func $foo))
@@ -32,8 +32,8 @@
   ;; CLOSD:      (type $foo_t (func))
   (type $foo_t (func))
 
-  ;; CHECK:      (global $func-null-init (mut (exact nullfuncref)) (ref.null nofunc))
-  ;; CLOSD:      (global $func-null-init (mut (exact nullfuncref)) (ref.null nofunc))
+  ;; CHECK:      (global $func-null-init (mut nullfuncref) (ref.null nofunc))
+  ;; CLOSD:      (global $func-null-init (mut nullfuncref) (ref.null nofunc))
   (global $func-null-init (mut funcref) (ref.null $foo_t))
   ;; CHECK:      (global $func-func-init (mut (ref null $foo_t)) (ref.func $foo))
   ;; CLOSD:      (global $func-func-init (mut (ref null $foo_t)) (ref.func $foo))
@@ -202,16 +202,16 @@
 ;; (ref null func) to nullfuncref only when not exported, and if exported, then
 ;; only when immutable in open world.
 (module
-  ;; CHECK:      (global $mut (mut (exact nullfuncref)) (ref.null nofunc))
-  ;; CLOSD:      (global $mut (mut (exact nullfuncref)) (ref.null nofunc))
+  ;; CHECK:      (global $mut (mut nullfuncref) (ref.null nofunc))
+  ;; CLOSD:      (global $mut (mut nullfuncref) (ref.null nofunc))
   (global $mut (mut (ref null func)) (ref.null nofunc))
-  ;; CHECK:      (global $imm (exact nullfuncref) (ref.null nofunc))
-  ;; CLOSD:      (global $imm (exact nullfuncref) (ref.null nofunc))
+  ;; CHECK:      (global $imm nullfuncref (ref.null nofunc))
+  ;; CLOSD:      (global $imm nullfuncref (ref.null nofunc))
   (global $imm (ref null func) (ref.null nofunc))
   ;; CHECK:      (global $mut-exp (mut funcref) (ref.null nofunc))
   ;; CLOSD:      (global $mut-exp (mut funcref) (ref.null nofunc))
   (global $mut-exp (mut (ref null func)) (ref.null nofunc))
-  ;; CHECK:      (global $imm-exp (exact nullfuncref) (ref.null nofunc))
+  ;; CHECK:      (global $imm-exp nullfuncref (ref.null nofunc))
   ;; CLOSD:      (global $imm-exp funcref (ref.null nofunc))
   (global $imm-exp (ref null func) (ref.null nofunc))