Add wasmparser support for ref.{test,cast} (#1332)

* Add `wasmparser` support for `ref.{test,cast}`

This also splits `wasm-encoder::Intruction::Ref{Test,Cast}` into nullable and
non-nullable forms, since that more directly aligns with the binary format where
there are actually different opcodes for nullable vs non-nullable variations (as
opposed to a bit on some immediate or something).

* Add copy of subset of `ref.{test,cast}` tests

Not all are passing yet, but this is more related to our type canonicalization
and match checking than `ref.{test,cast}`. So in the meantime, check that the
subset of the spec tests that are passing continue to pass. Once we get all of
them passing we can enable the spec tests and delete this partial copy.

* more concise

* fill out todo message

Author: fitzgen

crates/wasm-encoder/src/core/code.rs

@@ -1,4 +1,4 @@
-use crate::{encode_section, Encode, HeapType, RefType, Section, SectionId, ValType};
+use crate::{encode_section, Encode, HeapType, Section, SectionId, ValType};
 use std::borrow::Cow;
 
 /// An encoder for the code section.
@@ -546,8 +546,10 @@ pub enum Instruction<'a> {
     ArrayInitData(u32, u32),
     ArrayInitElem(u32, u32),
 
-    RefTest(RefType),
-    RefCast(RefType),
+    RefTestNonNull(HeapType),
+    RefTestNullable(HeapType),
+    RefCastNonNull(HeapType),
+    RefCastNullable(HeapType),
     AnyConvertExtern,
     ExternConvertAny,
 
@@ -1459,34 +1461,22 @@ impl Encode for Instruction<'_> {
                 type_index.encode(sink);
                 elem_index.encode(sink);
             }
-            Instruction::RefTest(RefType {
-                nullable: false,
-                heap_type,
-            }) => {
+            Instruction::RefTestNonNull(heap_type) => {
                 sink.push(0xfb);
                 sink.push(0x14);
                 heap_type.encode(sink);
             }
-            Instruction::RefTest(RefType {
-                nullable: true,
-                heap_type,
-            }) => {
+            Instruction::RefTestNullable(heap_type) => {
                 sink.push(0xfb);
                 sink.push(0x15);
                 heap_type.encode(sink);
             }
-            Instruction::RefCast(RefType {
-                nullable: false,
-                heap_type,
-            }) => {
+            Instruction::RefCastNonNull(heap_type) => {
                 sink.push(0xfb);
                 sink.push(0x16);
                 heap_type.encode(sink);
             }
-            Instruction::RefCast(RefType {
-                nullable: true,
-                heap_type,
-            }) => {
+            Instruction::RefCastNullable(heap_type) => {
                 sink.push(0xfb);
                 sink.push(0x17);
                 heap_type.encode(sink);

crates/wasm-shrink/tests/tests.rs

@@ -29,7 +29,7 @@ fn shrink_to_empty_is_error() -> Result<()> {
     let result = WasmShrink::default().run(wasm(), |_| Ok(true));
     assert!(result.is_err());
     let err_msg = result.err().unwrap().to_string();
-    assert!(dbg!(err_msg).contains("empty Wasm module"));
+    assert!(err_msg.contains("empty Wasm module"));
     Ok(())
 }
 

crates/wasmparser/src/binary_reader.rs

@@ -1001,6 +1001,11 @@ impl<'a> BinaryReader<'a> {
     {
         let code = self.read_var_u32()?;
         Ok(match code {
+            0x14 => visitor.visit_ref_test_non_null(self.read()?),
+            0x15 => visitor.visit_ref_test_nullable(self.read()?),
+            0x16 => visitor.visit_ref_cast_non_null(self.read()?),
+            0x17 => visitor.visit_ref_cast_nullable(self.read()?),
+
             0x1c => visitor.visit_ref_i31(),
             0x1d => visitor.visit_i31_get_s(),
             0x1e => visitor.visit_i31_get_u(),

crates/wasmparser/src/lib.rs

@@ -319,6 +319,10 @@ macro_rules! for_each_operator {
             @gc RefI31 => visit_ref_i31
             @gc I31GetS => visit_i31_get_s
             @gc I31GetU => visit_i31_get_u
+            @gc RefTestNonNull { hty: $crate::HeapType } => visit_ref_test_non_null
+            @gc RefTestNullable { hty: $crate::HeapType } => visit_ref_test_nullable
+            @gc RefCastNonNull { hty: $crate::HeapType } => visit_ref_cast_non_null
+            @gc RefCastNullable { hty: $crate::HeapType } => visit_ref_cast_nullable
 
             // 0xFC operators
             // Non-trapping Float-to-int Conversions

crates/wasmparser/src/validator/core.rs

@@ -596,7 +596,7 @@ impl Module {
                 bail!(offset, "sub type cannot have a final super type");
             }
             if !types.matches(id, sup_id) {
-                bail!(offset, "subtype must match supertype");
+                bail!(offset, "sub type must match super type");
             }
         }
 

crates/wasmparser/src/validator/operators.rs

@@ -970,6 +970,50 @@ where
         Ok(())
     }
 
+    /// Common helper for `ref.test` and `ref.cast` downcasting/checking
+    /// instructions. Returns the given `heap_type` as a `ValType`.
+    fn check_downcast(&mut self, nullable: bool, mut heap_type: HeapType) -> Result<ValType> {
+        self.resources
+            .check_heap_type(&mut heap_type, self.offset)?;
+
+        let sub_ty = RefType::new(nullable, heap_type)
+            .map(ValType::from)
+            .ok_or_else(|| {
+                BinaryReaderError::new("implementation limit: type index too large", self.offset)
+            })?;
+
+        let sup_ty = match self.pop_ref()? {
+            None => bail!(
+                self.offset,
+                "type mismatch: expected (ref null? ...), found bottom"
+            ),
+            Some(ty) => ty,
+        };
+
+        if !self.resources.is_subtype(sub_ty, sup_ty.into()) {
+            bail!(
+                self.offset,
+                "ref.test's heap type must be a sub type of the type on the stack"
+            );
+        }
+
+        Ok(sub_ty)
+    }
+
+    /// Common helper for both nullable and non-nullable variants of `ref.test`
+    /// instructions.
+    fn check_ref_test(&mut self, nullable: bool, heap_type: HeapType) -> Result<()> {
+        self.check_downcast(nullable, heap_type)?;
+        self.push_operand(ValType::I32)
+    }
+
+    /// Common helper for both nullable and non-nullable variants of `ref.cast`
+    /// instructions.
+    fn check_ref_cast(&mut self, nullable: bool, heap_type: HeapType) -> Result<()> {
+        let sub_ty = self.check_downcast(nullable, heap_type)?;
+        self.push_operand(sub_ty)
+    }
+
     fn func_type_at(&self, at: u32) -> Result<&'resources R::FuncType> {
         self.resources
             .func_type_at(at)
@@ -3387,6 +3431,18 @@ where
         self.pop_operand(Some(ValType::I32))?;
         Ok(())
     }
+    fn visit_ref_test_non_null(&mut self, heap_type: HeapType) -> Self::Output {
+        self.check_ref_test(false, heap_type)
+    }
+    fn visit_ref_test_nullable(&mut self, heap_type: HeapType) -> Self::Output {
+        self.check_ref_test(true, heap_type)
+    }
+    fn visit_ref_cast_non_null(&mut self, heap_type: HeapType) -> Self::Output {
+        self.check_ref_cast(false, heap_type)
+    }
+    fn visit_ref_cast_nullable(&mut self, heap_type: HeapType) -> Self::Output {
+        self.check_ref_cast(true, heap_type)
+    }
     fn visit_ref_i31(&mut self) -> Self::Output {
         self.pop_operand(Some(ValType::I32))?;
         self.push_operand(ValType::Ref(RefType::I31))

crates/wasmprinter/src/operator.rs

@@ -1,7 +1,7 @@
 use super::{Printer, State};
-use anyhow::{bail, Result};
+use anyhow::{anyhow, bail, Result};
 use std::fmt::Write;
-use wasmparser::{BlockType, BrTable, MemArg, VisitOperator};
+use wasmparser::{BlockType, BrTable, MemArg, RefType, VisitOperator};
 
 pub struct PrintOperator<'a, 'b> {
     pub(super) printer: &'a mut Printer,
@@ -316,6 +316,30 @@ macro_rules! define_visit {
             )?;
         }
     );
+    (payload $self:ident RefTestNonNull $hty:ident) => (
+        $self.push_str(" ");
+        let rty = RefType::new(false, $hty)
+            .ok_or_else(|| anyhow!("implementation limit: type index too large"))?;
+        $self.printer.print_reftype(rty)?;
+    );
+    (payload $self:ident RefTestNullable $hty:ident) => (
+        $self.push_str(" ");
+        let rty = RefType::new(true, $hty)
+            .ok_or_else(|| anyhow!("implementation limit: type index too large"))?;
+        $self.printer.print_reftype(rty)?;
+    );
+    (payload $self:ident RefCastNonNull $hty:ident) => (
+        $self.push_str(" ");
+        let rty = RefType::new(false, $hty)
+            .ok_or_else(|| anyhow!("implementation limit: type index too large"))?;
+        $self.printer.print_reftype(rty)?;
+    );
+    (payload $self:ident RefCastNullable $hty:ident) => (
+        $self.push_str(" ");
+        let rty = RefType::new(true, $hty)
+            .ok_or_else(|| anyhow!("implementation limit: type index too large"))?;
+        $self.printer.print_reftype(rty)?;
+    );
     (payload $self:ident $op:ident $($arg:ident)*) => (
         $(
             $self.push_str(" ");
@@ -861,6 +885,10 @@ macro_rules! define_visit {
     (name I16x8RelaxedQ15mulrS) => ("i16x8.relaxed_q15mulr_s");
     (name I16x8RelaxedDotI8x16I7x16S) => ("i16x8.relaxed_dot_i8x16_i7x16_s");
     (name I32x4RelaxedDotI8x16I7x16AddS) => ("i32x4.relaxed_dot_i8x16_i7x16_add_s");
+    (name RefTestNonNull) => ("ref.test");
+    (name RefTestNullable) => ("ref.test");
+    (name RefCastNonNull) => ("ref.cast");
+    (name RefCastNullable) => ("ref.cast");
     (name RefI31) => ("ref.i31");
     (name I31GetS) => ("i31.get_s");
     (name I31GetU) => ("i31.get_u");

tests/local/gc/gc-rec-groups-invalid.wast

@@ -27,4 +27,4 @@
       (type $t4 (sub $t2 (struct (field (ref $t3)))))
     )
   )
-  "subtype must match supertype")
+  "sub type must match super type")

tests/local/gc/gc-subtypes-invalid.wast

@@ -20,21 +20,21 @@
     (type $a (sub (func)))
     (type $b (sub $a (struct))) ;; invalid
   )
-  "subtype must match supertype"
+  "sub type must match super type"
 )
 (assert_invalid
   (module
     (type $a (sub (func)))
     (type $b (sub $a (func (param i32)))) ;; invalid
   )
-  "subtype must match supertype"
+  "sub type must match super type"
 )
 (assert_invalid
   (module
     (type $a (sub (struct (field i32))))
     (type $b (sub $a (struct (field i64)))) ;; invalid
   )
-  "subtype must match supertype"
+  "sub type must match super type"
 )
 (assert_invalid
   (module
@@ -45,21 +45,21 @@
     (type $g (sub (func (param (ref $e)) (result (ref $e)))))
     (type $i (sub $g (func (param (ref $f)) (result (ref $d))))) ;; invalid
   )
-  "subtype must match supertype"
+  "sub type must match super type"
 )
 (assert_invalid
   (module
     (type $o (sub (array i32)))
     (type (sub $o (array (mut i32)))) ;; invalid
   )
-  "subtype must match supertype"
+  "sub type must match super type"
 )
 (assert_invalid
   (module
     (type $o (sub (array i32)))
     (type (sub $o (array i64))) ;; invalid
   )
-  "subtype must match supertype"
+  "sub type must match super type"
 )
 (assert_invalid
   (module
@@ -68,7 +68,7 @@
     (type $s (sub $r (array (ref i31))))
     (type (sub $s (array (ref null i31)))) ;; invalid
   )
-  "subtype must match supertype"
+  "sub type must match super type"
 )
 (assert_invalid
   (module
@@ -77,7 +77,7 @@
     (type $ss (sub $rr (array (ref array))))
     (type (sub $ss (array (ref null array)))) ;; invalid
   )
-  "subtype must match supertype"
+  "sub type must match super type"
 )
 (assert_invalid
   (module
@@ -86,31 +86,31 @@
     (type $sss (sub $rrr (array (ref struct))))
     (type (sub $sss (array (ref null struct)))) ;; invalid
   )
-  "subtype must match supertype"
+  "sub type must match super type"
 )
 (assert_invalid
   (module
     (type $t (sub (array (mut funcref))))
     (type $u (sub $t (array (ref null func))))
     (type (sub $u (array (mut (ref func))))) ;; invalid
   )
-  "subtype must match supertype"
+  "sub type must match super type"
 )
 (assert_invalid
   (module
     (type $t (sub (array (mut funcref))))
     (type $u (sub $t (array (ref null func))))
     (type (sub $u (array (ref null extern)))) ;; invalid
   )
-  "subtype must match supertype"
+  "sub type must match super type"
 )
 (assert_invalid
   (module
     (type $t0 (sub (array (mut externref))))
     (type $u0 (sub $t0 (array (ref null extern))))
     (type (sub $u0 (array (mut (ref extern))))) ;; invalid
   )
-  "subtype must match supertype"
+  "sub type must match super type"
 )
 (assert_invalid
   (module
@@ -119,14 +119,14 @@
     (type $v0 (sub $u0 (array (ref extern))))
     (type (sub $v0 (array nullexternref))) ;; invalid
   )
-  "subtype must match supertype"
+  "sub type must match super type"
 )
 (assert_invalid
   (module
     (type $t (sub (array (mut funcref))))
     (type (sub $t (array nullexternref))) ;; invalid
   )
-  "subtype must match supertype"
+  "sub type must match super type"
 )
 (assert_invalid
   (module