[spec/interpreter/test] Allow nullref type externally (#66)

Author: rossberg

document/core/appendix/index-types.rst

@@ -15,7 +15,8 @@ Category                                  Constructor
 (reserved)                                                                             :math:`\hex{7B}` .. :math:`\hex{71}`
 :ref:`Reference type <syntax-reftype>`    |FUNCREF|                                    :math:`\hex{70}` (-16 as |Bs7|)
 :ref:`Reference type <syntax-reftype>`    |ANYREF|                                     :math:`\hex{6F}` (-17 as |Bs7|)
-(reserved)                                                                             :math:`\hex{6E}` .. :math:`\hex{61}`
+:ref:`Reference type <syntax-reftype>`    |NULLREF|                                    :math:`\hex{6E}` (-18 as |Bs7|)
+(reserved)                                                                             :math:`\hex{6D}` .. :math:`\hex{61}`
 :ref:`Function type <syntax-functype>`    :math:`[\valtype^\ast] \to [\valtype^\ast]`  :math:`\hex{60}` (-32 as |Bs7|)
 (reserved)                                                                             :math:`\hex{5F}` .. :math:`\hex{41}`
 :ref:`Result type <syntax-resulttype>`    :math:`[\epsilon]`                             :math:`\hex{40}` (-64 as |Bs7|)

document/core/binary/types.rst

@@ -42,12 +42,10 @@ Reference Types
    \begin{array}{llclll@{\qquad\qquad}l}
    \production{reference type} & \Breftype &::=&
      \hex{70} &\Rightarrow& \FUNCREF \\ &&|&
-     \hex{6F} &\Rightarrow& \ANYREF \\
+     \hex{6F} &\Rightarrow& \ANYREF \\ &&|&
+     \hex{6E} &\Rightarrow& \NULLREF \\
    \end{array}
 
-.. note::
-   The type :math:`\NULLREF` cannot occur in a module.
-
 
 .. index:: value type, number type, reference type
    pair: binary format; value type

document/core/syntax/types.rst

@@ -63,8 +63,6 @@ The type |FUNCREF| denotes the infinite union of all references to :ref:`functio
 
 The type |NULLREF| only contains a single value: the :ref:`null <syntax-ref.null>` reference.
 It is a :ref:`subtype <match-reftype>` of all other reference types.
-By virtue of being representable in neither the :ref:`binary format <binary-reftype>` nor the :ref:`text format <text-reftype>`, the |NULLREF| type cannot be used in a program;
-it only occurs during :ref:`validation <valid>`.
 
 .. note::
    Future versions of WebAssembly may include reference types that do not include null and hence are not supertypes of |NULLREF|.

document/core/text/types.rst

@@ -33,7 +33,8 @@ Reference Types
    \begin{array}{llcll@{\qquad\qquad}l}
    \production{reference type} & \Treftype &::=&
      \text{anyref} &\Rightarrow& \ANYREF \\ &&|&
-     \text{funcref} &\Rightarrow& \FUNCREF \\
+     \text{funcref} &\Rightarrow& \FUNCREF \\ &&|&
+     \text{nullref} &\Rightarrow& \NULLREF \\
    \end{array}
 
 

document/js-api/index.bs

@@ -152,6 +152,7 @@ urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: df
     url: syntax/types.html#syntax-reftype
         text: anyref
         text: funcref
+        text: nullref
     text: function element; url: exec/runtime.html#syntax-funcelem
     text: import component; url: syntax/modules.html#imports
     text: external value; url: exec/runtime.html#syntax-externval
@@ -704,6 +705,7 @@ Immediately after a WebAssembly [=memory.grow=] instruction executes, perform th
 
 <pre class="idl">
 enum TableKind {
+  "nullref",
   "anyref",
   "anyfunc",
   // Note: More values may be added in future iterations,
@@ -868,6 +870,10 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. If |s| equals "i64", return [=𝗂𝟨𝟦=].
     1. If |s| equals "f32", return [=𝖿𝟥𝟤=].
     1. If |s| equals "f64", return [=𝖿𝟨𝟦=].
+    1. If |s| equals "anyref", return [=anyref=].
+    1. If |s| equals "funcref", return [=funcref=].
+    1. If |s| equals "nullref", return [=nullref=].
+    1. Assert: This step is not reached.
 </div>
 
 <div algorithm>
@@ -876,7 +882,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. If |valuetype| equals [=𝗂𝟨𝟦=], return [=𝗂𝟨𝟦.𝖼𝗈𝗇𝗌𝗍=] 0.
     1. If |valuetype| equals [=𝖿𝟥𝟤=], return [=𝖿𝟥𝟤.𝖼𝗈𝗇𝗌𝗍=] 0.
     1. If |valuetype| equals [=𝖿𝟨𝟦=], return [=𝖿𝟨𝟦.𝖼𝗈𝗇𝗌𝗍=] 0.
-    1. Assert: This step is not reached.
+    1. Else, return [=ref.null=].
 </div>
 
 <div algorithm>
@@ -1063,11 +1069,14 @@ The algorithm <dfn>ToWebAssemblyValue</dfn>(|v|, |type|, |error|) coerces a Java
 1. If |type| is [=𝖿𝟨𝟦=],
     1. Let |f64| be ? [=ToNumber=](|v|).
     1. Return [=𝖿𝟨𝟦.𝖼𝗈𝗇𝗌𝗍=] |f64|.
+1. Assert: |type| is a reference type.
 1. If |type| is [=anyref=],
-    1. Return the result of [=allocating a host address=] for |v|.
+    1. Do nothing.
 1. If |type| is [=funcref=],
     1. If |v| is not an [=Exported function=] or null, throw |error|.
-    1. Return the result of [=allocating a host address=] for |v|.
+1. If |type| is [=nullref=],
+    1. If |v| is not null, throw |error|.
+1. Return the result of [=allocating a host address=] for |v|.
 
 </div>
 

interpreter/README.md

@@ -184,7 +184,7 @@ align: align=(1|2|4|8|...)
 cvtop: trunc | extend | wrap | ...
 
 num_type: i32 | i64 | f32 | f64
-ref_type: anyref | funcref
+ref_type: anyref | funcref | nullref
 val_type: num_type | ref_type
 block_type : ( result <val_type>* )*
 func_type:   ( type <var> )? <param>* <result>*

interpreter/binary/decode.ml

@@ -145,6 +145,7 @@ let ref_type s =
   match vs7 s with
   | -0x10 -> FuncRefType
   | -0x11 -> AnyRefType
+  | -0x12 -> NullRefType
   | _ -> error s (pos s - 1) "invalid reference type"
 
 let value_type s =

interpreter/binary/encode.ml

@@ -99,7 +99,7 @@ let encode m =
     let ref_type = function
       | FuncRefType -> vs7 (-0x10)
       | AnyRefType -> vs7 (-0x11)
-      | NullRefType -> assert false
+      | NullRefType -> vs7 (-0x12)
 
     let value_type = function
       | NumType t -> num_type t

interpreter/text/lexer.mll

@@ -162,6 +162,7 @@ rule token = parse
 
   | "anyref" { ANYREF }
   | "funcref" { FUNCREF }
+  | "nullref" { NULLREF }
   | (nxx as t) { NUM_TYPE (num_type t) }
   | "mut" { MUT }
 

interpreter/text/parser.mly

@@ -147,7 +147,7 @@ let inline_type_explicit (c : context) x ft at =
 
 %token LPAR RPAR
 %token NAT INT FLOAT STRING VAR
-%token ANYREF FUNCREF NUM_TYPE MUT
+%token ANYREF NULLREF FUNCREF NUM_TYPE MUT
 %token UNREACHABLE NOP DROP SELECT
 %token BLOCK END IF THEN ELSE LOOP BR BR_IF BR_TABLE
 %token CALL CALL_INDIRECT RETURN
@@ -209,6 +209,7 @@ string_list :
 ref_type :
   | ANYREF { AnyRefType }
   | FUNCREF { FuncRefType }
+  | NULLREF { NullRefType }
 
 value_type :
   | NUM_TYPE { NumType $1 }