fix: Fix non-nullable assertion for externref-s

src/compiler.ts

@@ -25,7 +25,6 @@ import {
   ExpressionRef,
   UnaryOp,
   BinaryOp,
-  RefIsOp,
   TypeRef,
   FunctionRef,
   ExpressionId,
@@ -10331,11 +10330,11 @@ export class Compiler extends DiagnosticEmitter {
       case TypeKind.EXTERNREF:
       case TypeKind.ANYREF:
       case TypeKind.EQREF:
-      case TypeKind.DATAREF:
-      case TypeKind.I31REF: {
+      case TypeKind.I31REF:
+      case TypeKind.DATAREF: {
         // Needs to be true (i.e. not zero) when the ref is _not_ null,
         // which means `ref.is_null` returns false (i.e. zero).
-        return module.unary(UnaryOp.EqzI32, module.ref_is(RefIsOp.RefIsNull, expr));
+        return module.unary(UnaryOp.EqzI32, module.ref_is_null(expr));
 
       }
       default: {
@@ -10585,11 +10584,23 @@ export class Compiler extends DiagnosticEmitter {
     var temp = flow.getTempLocal(type);
     if (!flow.canOverflow(expr, type)) flow.setLocalFlag(temp.index, LocalFlags.WRAPPED);
     flow.setLocalFlag(temp.index, LocalFlags.NONNULL);
-    expr = module.if(
-      module.local_tee(temp.index, expr, type.isManaged),
-      module.local_get(temp.index, type.toRef()),
-      this.makeStaticAbort(this.ensureStaticString("unexpected null"), reportNode) // TODO: throw
-    );
+    if (type.kind >= TypeKind.FUNCREF && type.kind <= TypeKind.DATAREF) {
+      let nonNullExpr = module.local_get(temp.index, type.toRef());
+      if (this.options.hasFeature(Feature.GC)) {
+        nonNullExpr = module.ref_as_nonnull(nonNullExpr);
+      }
+      expr = module.if(
+        module.ref_is_null(module.local_tee(temp.index, expr, false)),
+        this.makeStaticAbort(this.ensureStaticString("unexpected null"), reportNode), // TODO: throw
+        nonNullExpr
+      );
+    } else {
+      expr = module.if(
+        module.local_tee(temp.index, expr, type.isManaged),
+        module.local_get(temp.index, type.toRef()),
+        this.makeStaticAbort(this.ensureStaticString("unexpected null"), reportNode) // TODO: throw
+      );
+    }
     flow.freeTempLocal(temp);
     this.currentType = type.nonNullableType;
     return expr;

src/module.ts

@@ -1774,13 +1774,25 @@ export class Module {
     return binaryen._BinaryenRefIs(this.ref, op, expr);
   }
 
+  ref_is_null(
+    expr: ExpressionRef
+  ): ExpressionRef {
+    return binaryen._BinaryenRefIs(this.ref, RefIsOp.RefIsNull, expr);
+  }
+
   ref_as(
     op: RefAsOp,
     expr: ExpressionRef
   ): ExpressionRef {
     return binaryen._BinaryenRefAs(this.ref, op, expr);
   }
 
+  ref_as_nonnull(
+    expr: ExpressionRef
+  ): ExpressionRef {
+    return binaryen._BinaryenRefAs(this.ref, RefAsOp.RefAsNonNull, expr);
+  }
+
   ref_func(
     name: string,
     type: TypeRef

src/passes/pass.ts

@@ -81,6 +81,7 @@ import {
   _BinaryenMemoryFillGetValue,
   _BinaryenMemoryFillGetSize,
   _BinaryenRefIsGetValue,
+  _BinaryenRefAsGetValue,
   _BinaryenTryGetBody,
   _BinaryenTryGetNumCatchBodies,
   _BinaryenTryGetCatchBodyAt,
@@ -989,7 +990,7 @@ export abstract class Visitor {
       }
       case ExpressionId.RefAs: {
         this.stack.push(expr);
-        assert(false); // TODO
+        this.visit(_BinaryenRefAsGetValue(expr));
         assert(this.stack.pop() == expr);
         this.visitRefAs(expr);
         break;

tests/compiler/features/reference-types.debug.wat

@@ -14,11 +14,14 @@
  (global $features/reference-types/otherFuncGlobal (mut funcref) (ref.func $features/reference-types/someFunc))
  (global $features/reference-types/a anyref (ref.null any))
  (global $features/reference-types/b funcref (ref.null func))
- (global $~lib/memory/__data_end i32 (i32.const 92))
- (global $~lib/memory/__stack_pointer (mut i32) (i32.const 16476))
- (global $~lib/memory/__heap_base i32 (i32.const 16476))
+ (global $features/reference-types/nonNullFunc (mut funcref) (ref.null func))
+ (global $features/reference-types/nonNullReal (mut anyref) (ref.null any))
+ (global $~lib/memory/__data_end i32 (i32.const 156))
+ (global $~lib/memory/__stack_pointer (mut i32) (i32.const 16540))
+ (global $~lib/memory/__heap_base i32 (i32.const 16540))
  (memory $0 1)
  (data (i32.const 12) "L\00\00\00\00\00\00\00\00\00\00\00\01\00\00\006\00\00\00f\00e\00a\00t\00u\00r\00e\00s\00/\00r\00e\00f\00e\00r\00e\00n\00c\00e\00-\00t\00y\00p\00e\00s\00.\00t\00s\00\00\00\00\00\00\00")
+ (data (i32.const 92) "<\00\00\00\00\00\00\00\00\00\00\00\01\00\00\00\1e\00\00\00u\00n\00e\00x\00p\00e\00c\00t\00e\00d\00 \00n\00u\00l\00l\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00")
  (table $0 1 1 funcref)
  (elem $0 (i32.const 1))
  (elem declare func $features/reference-types/someFunc)
@@ -28,6 +31,8 @@
  (export "internal" (func $features/reference-types/internal))
  (export "a" (global $features/reference-types/a))
  (export "b" (global $features/reference-types/b))
+ (export "nonNullFunc" (global $features/reference-types/nonNullFunc))
+ (export "nonNullReal" (global $features/reference-types/nonNullReal))
  (export "memory" (memory $0))
  (start $~start)
  (func $features/reference-types/testLocal<funcref>
@@ -77,7 +82,7 @@
    unreachable
   end
  )
- (func $features/reference-types/testLocal<anyref>
+ (func $features/reference-types/testLocal<externref>
   (local $0 anyref)
   (local $1 anyref)
   local.get $0
@@ -129,6 +134,7 @@
  )
  (func $start:features/reference-types
   (local $0 funcref)
+  (local $1 anyref)
   call $features/reference-types/somethingReal
   ref.is_null
   i32.eqz
@@ -278,7 +284,7 @@
    unreachable
   end
   call $features/reference-types/testLocal<funcref>
-  call $features/reference-types/testLocal<anyref>
+  call $features/reference-types/testLocal<externref>
   ref.func $features/reference-types/someFunc
   global.set $features/reference-types/funcGlobal
   global.get $features/reference-types/funcGlobal
@@ -301,20 +307,46 @@
    call $~lib/builtins/abort
    unreachable
   end
-  block
-   ref.func $features/reference-types/someFunc
-   local.set $0
+  ref.func $features/reference-types/someFunc
+  local.set $0
+  local.get $0
+  ref.is_null
+  if
+   i32.const 0
+   i32.const 32
+   i32.const 88
+   i32.const 3
+   call $~lib/builtins/abort
+   unreachable
+  end
+  global.get $features/reference-types/otherFuncGlobal
+  local.tee $0
+  ref.is_null
+  if (result funcref)
+   i32.const 112
+   i32.const 32
+   i32.const 97
+   i32.const 28
+   call $~lib/builtins/abort
+   unreachable
+  else
    local.get $0
-   ref.is_null
-   if
-    i32.const 0
-    i32.const 32
-    i32.const 88
-    i32.const 3
-    call $~lib/builtins/abort
-    unreachable
-   end
   end
+  global.set $features/reference-types/nonNullFunc
+  call $features/reference-types/somethingReal
+  local.tee $1
+  ref.is_null
+  if (result anyref)
+   i32.const 112
+   i32.const 32
+   i32.const 98
+   i32.const 28
+   call $~lib/builtins/abort
+   unreachable
+  else
+   local.get $1
+  end
+  global.set $features/reference-types/nonNullReal
  )
  (func $features/reference-types/internal (param $0 anyref) (result anyref)
   (local $1 anyref)

tests/compiler/features/reference-types.json

@@ -1,7 +1,6 @@
 {
   "features": [
-    "reference-types",
-    "gc"
+    "reference-types"
   ],
   "asc_flags": [
   ]

tests/compiler/features/reference-types.release.wat

@@ -10,16 +10,22 @@
  (global $features/reference-types/funcGlobal (mut funcref) (ref.null func))
  (global $features/reference-types/a anyref (ref.null any))
  (global $features/reference-types/b funcref (ref.null func))
+ (global $features/reference-types/nonNullFunc (mut funcref) (ref.null func))
+ (global $features/reference-types/nonNullReal (mut anyref) (ref.null any))
  (memory $0 1)
  (data (i32.const 1036) "L")
  (data (i32.const 1048) "\01\00\00\006\00\00\00f\00e\00a\00t\00u\00r\00e\00s\00/\00r\00e\00f\00e\00r\00e\00n\00c\00e\00-\00t\00y\00p\00e\00s\00.\00t\00s")
+ (data (i32.const 1116) "<")
+ (data (i32.const 1128) "\01\00\00\00\1e\00\00\00u\00n\00e\00x\00p\00e\00c\00t\00e\00d\00 \00n\00u\00l\00l")
  (elem declare func $features/reference-types/someFunc)
  (export "external" (func $features/reference-types/external))
  (export "somethingReal" (func $features/reference-types/somethingReal))
  (export "somethingNull" (func $features/reference-types/somethingNull))
  (export "internal" (func $features/reference-types/internal))
  (export "a" (global $features/reference-types/a))
  (export "b" (global $features/reference-types/b))
+ (export "nonNullFunc" (global $features/reference-types/nonNullFunc))
+ (export "nonNullReal" (global $features/reference-types/nonNullReal))
  (export "memory" (memory $0))
  (start $~start)
  (func $features/reference-types/someFunc
@@ -32,6 +38,7 @@
   call $features/reference-types/external
  )
  (func $~start
+  (local $0 anyref)
   call $features/reference-types/somethingReal
   ref.is_null
   if
@@ -89,5 +96,20 @@
   global.set $features/reference-types/funcGlobal
   ref.func $features/reference-types/someFunc
   global.set $features/reference-types/funcGlobal
+  ref.func $features/reference-types/someFunc
+  global.set $features/reference-types/nonNullFunc
+  call $features/reference-types/somethingReal
+  local.tee $0
+  ref.is_null
+  if
+   i32.const 1136
+   i32.const 1056
+   i32.const 98
+   i32.const 28
+   call $~lib/builtins/abort
+   unreachable
+  end
+  local.get $0
+  global.set $features/reference-types/nonNullReal
  )
 )

tests/compiler/features/reference-types.ts

@@ -1,31 +1,31 @@
 // can use anyref as a parameter or return type
 
-export declare function external(a: anyref): anyref;
-export declare function somethingReal(): anyref;
-export declare function somethingNull(): anyref;
+export declare function external(a: externref): externref;
+export declare function somethingReal(): externref;
+export declare function somethingNull(): externref;
 
-export function internal(a: anyref): anyref {
+export function internal(a: externref): externref {
   const b = external(a);
   let c = external(b);
   var d = external(c);
   return d;
 }
 
 // Truthiness conversion
-if(!somethingReal()) {
+if (!somethingReal()) {
   assert(false);
 }
-if(!somethingNull()) {
+if (!somethingNull()) {
   // nop
 } else {
   assert(false);
 }
-if(somethingReal()) {
+if (somethingReal()) {
   // nop
 } else {
   assert(false);
 }
-if(somethingNull()) {
+if (somethingNull()) {
   assert(false);
 }
 
@@ -58,11 +58,11 @@ assert(!funcGlobal);
 var funcGlobalInit: funcref = null;
 assert(!funcGlobalInit);
 
-var anyGlobal: anyref;
+var anyGlobal: externref;
 assert(!anyGlobal);
 anyGlobal = null;
 assert(!anyGlobal);
-var anyGlobalInit: anyref = null;
+var anyGlobalInit: externref = null;
 assert(!anyGlobalInit);
 
 function testLocal<T>(): void {
@@ -74,7 +74,7 @@ function testLocal<T>(): void {
   assert(!localInit);
 }
 testLocal<funcref>();
-testLocal<anyref>();
+testLocal<externref>();
 
 // funcref can represent function references
 
@@ -90,5 +90,9 @@ assert(otherFuncGlobal);
 
 // constant globals
 
-export const a: anyref = null;
+export const a: externref = null;
 export const b: funcref = null;
+
+// non-null assertions
+export const nonNullFunc = otherFuncGlobal!;
+export const nonNullReal = somethingReal()!;