Update spec test suite submodule (#2444)

Pull in some renamings in the custom descriptors proposal.

Author: alexcrichton

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

@@ -1324,14 +1324,14 @@ pub enum Instruction<'a> {
     I64MulWideU,
 
     RefGetDesc(u32),
-    RefCastDescNonNull(HeapType),
-    RefCastDescNullable(HeapType),
-    BrOnCastDesc {
+    RefCastDescEqNonNull(HeapType),
+    RefCastDescEqNullable(HeapType),
+    BrOnCastDescEq {
         relative_depth: u32,
         from_ref_type: RefType,
         to_ref_type: RefType,
     },
-    BrOnCastDescFail {
+    BrOnCastDescEqFail {
         relative_depth: u32,
         from_ref_type: RefType,
         to_ref_type: RefType,
@@ -2173,18 +2173,18 @@ impl Encode for Instruction<'_> {
             Instruction::I64MulWideS => sink.i64_mul_wide_s(),
             Instruction::I64MulWideU => sink.i64_mul_wide_u(),
             Instruction::RefGetDesc(type_index) => sink.ref_get_desc(type_index),
-            Instruction::RefCastDescNonNull(hty) => sink.ref_cast_desc_non_null(hty),
-            Instruction::RefCastDescNullable(hty) => sink.ref_cast_desc_nullable(hty),
-            Instruction::BrOnCastDesc {
+            Instruction::RefCastDescEqNonNull(hty) => sink.ref_cast_desc_eq_non_null(hty),
+            Instruction::RefCastDescEqNullable(hty) => sink.ref_cast_desc_eq_nullable(hty),
+            Instruction::BrOnCastDescEq {
                 relative_depth,
                 from_ref_type,
                 to_ref_type,
-            } => sink.br_on_cast_desc(relative_depth, from_ref_type, to_ref_type),
-            Instruction::BrOnCastDescFail {
+            } => sink.br_on_cast_desc_eq(relative_depth, from_ref_type, to_ref_type),
+            Instruction::BrOnCastDescEqFail {
                 relative_depth,
                 from_ref_type,
                 to_ref_type,
-            } => sink.br_on_cast_desc_fail(relative_depth, from_ref_type, to_ref_type),
+            } => sink.br_on_cast_desc_eq_fail(relative_depth, from_ref_type, to_ref_type),
         };
     }
 }

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

@@ -4649,24 +4649,24 @@ impl<'a> InstructionSink<'a> {
         self
     }
 
-    /// Encode [`Instruction::RefCastDescNonNull`].
-    pub fn ref_cast_desc_non_null(&mut self, ht: HeapType) -> &mut Self {
+    /// Encode [`Instruction::RefCastDescEqNonNull`].
+    pub fn ref_cast_desc_eq_non_null(&mut self, ht: HeapType) -> &mut Self {
         self.sink.push(0xFB);
         35u32.encode(self.sink);
         ht.encode(self.sink);
         self
     }
 
-    /// Encode [`Instruction::RefCastDescNullable`].
-    pub fn ref_cast_desc_nullable(&mut self, ht: HeapType) -> &mut Self {
+    /// Encode [`Instruction::RefCastDescEqNullable`].
+    pub fn ref_cast_desc_eq_nullable(&mut self, ht: HeapType) -> &mut Self {
         self.sink.push(0xFB);
         36u32.encode(self.sink);
         ht.encode(self.sink);
         self
     }
 
-    /// Encode [`Instruction::BrOnCastDesc`].
-    pub fn br_on_cast_desc(
+    /// Encode [`Instruction::BrOnCastDescEq`].
+    pub fn br_on_cast_desc_eq(
         &mut self,
         relative_depth: u32,
         from_ref_type: RefType,
@@ -4682,8 +4682,8 @@ impl<'a> InstructionSink<'a> {
         self
     }
 
-    /// Encode [`Instruction::BrOnCastDescFail`].
-    pub fn br_on_cast_desc_fail(
+    /// Encode [`Instruction::BrOnCastDescEqFail`].
+    pub fn br_on_cast_desc_eq_fail(
         &mut self,
         relative_depth: u32,
         from_ref_type: RefType,

crates/wasmparser/src/arity.rs

@@ -307,7 +307,7 @@ fn visit_switch(module: &dyn ModuleArity, cont: u32, _tag: u32) -> Option<(u32,
     Some((params, cont_params))
 }
 
-fn visit_br_on_cast_desc(
+fn visit_br_on_cast_desc_eq(
     module: &dyn ModuleArity,
     depth: u32,
     _from: RefType,
@@ -317,7 +317,7 @@ fn visit_br_on_cast_desc(
     Some((params + 1, params))
 }
 
-fn visit_br_on_cast_desc_fail(
+fn visit_br_on_cast_desc_eq_fail(
     module: &dyn ModuleArity,
     depth: u32,
     _from: RefType,

crates/wasmparser/src/binary_reader.rs

@@ -1369,8 +1369,8 @@ impl<'a> BinaryReader<'a> {
                 visitor.visit_struct_new_default_desc(type_index)
             }
             0x22 => visitor.visit_ref_get_desc(self.read()?),
-            0x23 => visitor.visit_ref_cast_desc_non_null(self.read()?),
-            0x24 => visitor.visit_ref_cast_desc_nullable(self.read()?),
+            0x23 => visitor.visit_ref_cast_desc_eq_non_null(self.read()?),
+            0x24 => visitor.visit_ref_cast_desc_eq_nullable(self.read()?),
             0x25 => {
                 let pos = self.original_position();
                 let cast_flags = self.read_u8()?;
@@ -1392,7 +1392,7 @@ impl<'a> BinaryReader<'a> {
                     RefType::new(to_type_nullable, to_heap_type).ok_or_else(|| {
                         format_err!(pos, "implementation error: type index too large")
                     })?;
-                visitor.visit_br_on_cast_desc(relative_depth, from_ref_type, to_ref_type)
+                visitor.visit_br_on_cast_desc_eq(relative_depth, from_ref_type, to_ref_type)
             }
             0x26 => {
                 let pos = self.original_position();
@@ -1415,7 +1415,7 @@ impl<'a> BinaryReader<'a> {
                     RefType::new(to_type_nullable, to_heap_type).ok_or_else(|| {
                         format_err!(pos, "implementation error: type index too large")
                     })?;
-                visitor.visit_br_on_cast_desc_fail(relative_depth, from_ref_type, to_ref_type)
+                visitor.visit_br_on_cast_desc_eq_fail(relative_depth, from_ref_type, to_ref_type)
             }
 
             _ => bail!(pos, "unknown 0xfb subopcode: 0x{code:x}"),

crates/wasmparser/src/lib.rs

@@ -303,18 +303,18 @@ macro_rules! _for_each_operator_group {
                 StructNewDesc { struct_type_index: u32 } => visit_struct_new_desc (arity custom)
                 StructNewDefaultDesc { struct_type_index: u32 } => visit_struct_new_default_desc (arity 1 -> 1)
                 RefGetDesc { type_index: u32 } => visit_ref_get_desc (arity 1 -> 1)
-                RefCastDescNonNull { hty: $crate::HeapType } => visit_ref_cast_desc_non_null (arity 2 -> 1)
-                RefCastDescNullable { hty: $crate::HeapType } => visit_ref_cast_desc_nullable (arity 2 -> 1)
-                BrOnCastDesc {
+                RefCastDescEqNonNull { hty: $crate::HeapType } => visit_ref_cast_desc_eq_non_null (arity 2 -> 1)
+                RefCastDescEqNullable { hty: $crate::HeapType } => visit_ref_cast_desc_eq_nullable (arity 2 -> 1)
+                BrOnCastDescEq {
                     relative_depth: u32,
                     from_ref_type: $crate::RefType,
                     to_ref_type: $crate::RefType
-                } => visit_br_on_cast_desc (arity custom)
-                BrOnCastDescFail {
+                } => visit_br_on_cast_desc_eq (arity custom)
+                BrOnCastDescEqFail {
                     relative_depth: u32,
                     from_ref_type: $crate::RefType,
                     to_ref_type: $crate::RefType
-                } => visit_br_on_cast_desc_fail (arity custom)
+                } => visit_br_on_cast_desc_eq_fail (arity custom)
             }
 
             // 0xFC operators

crates/wasmparser/src/validator/operators.rs

@@ -1527,7 +1527,7 @@ where
 
     /// Common helper for both nullable and non-nullable variants of `ref.cast_desc`
     /// instructions.
-    fn check_ref_cast_desc(&mut self, nullable: bool, heap_type: HeapType) -> Result<()> {
+    fn check_ref_cast_desc_eq(&mut self, nullable: bool, heap_type: HeapType) -> Result<()> {
         let is_exact = self.check_maybe_exact_descriptor_ref(heap_type)?;
 
         self.check_downcast(nullable, heap_type)?;
@@ -4549,13 +4549,13 @@ where
         }
     }
 
-    fn visit_ref_cast_desc_non_null(&mut self, heap_type: HeapType) -> Self::Output {
-        self.check_ref_cast_desc(false, heap_type)
+    fn visit_ref_cast_desc_eq_non_null(&mut self, heap_type: HeapType) -> Self::Output {
+        self.check_ref_cast_desc_eq(false, heap_type)
     }
-    fn visit_ref_cast_desc_nullable(&mut self, heap_type: HeapType) -> Self::Output {
-        self.check_ref_cast_desc(true, heap_type)
+    fn visit_ref_cast_desc_eq_nullable(&mut self, heap_type: HeapType) -> Self::Output {
+        self.check_ref_cast_desc_eq(true, heap_type)
     }
-    fn visit_br_on_cast_desc(
+    fn visit_br_on_cast_desc_eq(
         &mut self,
         relative_depth: u32,
         mut from_ref_type: RefType,
@@ -4595,7 +4595,7 @@ where
         self.push_operand(diff_ty)?;
         Ok(())
     }
-    fn visit_br_on_cast_desc_fail(
+    fn visit_br_on_cast_desc_eq_fail(
         &mut self,
         relative_depth: u32,
         mut from_ref_type: RefType,

crates/wasmprinter/src/operator.rs

@@ -769,13 +769,13 @@ macro_rules! define_visit {
     (payload $self:ident RefGetDesc $hty:ident) => (
         $self.struct_type_index($hty)?;
     );
-    (payload $self:ident RefCastDescNonNull $hty:ident) => (
+    (payload $self:ident RefCastDescEqNonNull $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($self.state, rty)?;
     );
-    (payload $self:ident RefCastDescNullable $hty:ident) => (
+    (payload $self:ident RefCastDescEqNullable $hty:ident) => (
         $self.push_str(" ")?;
         let rty = RefType::new(true, $hty)
             .ok_or_else(|| anyhow!("implementation limit: type index too large"))?;
@@ -1409,10 +1409,10 @@ macro_rules! define_visit {
     (name I64MulWideS) => ("i64.mul_wide_s");
     (name I64MulWideU) => ("i64.mul_wide_u");
     (name RefGetDesc) => ("ref.get_desc");
-    (name RefCastDescNonNull) => ("ref.cast_desc");
-    (name RefCastDescNullable) => ("ref.cast_desc");
-    (name BrOnCastDesc) => ("br_on_cast_desc");
-    (name BrOnCastDescFail) => ("br_on_cast_desc_fail");
+    (name RefCastDescEqNonNull) => ("ref.cast_desc_eq");
+    (name RefCastDescEqNullable) => ("ref.cast_desc_eq");
+    (name BrOnCastDescEq) => ("br_on_cast_desc_eq");
+    (name BrOnCastDescEqFail) => ("br_on_cast_desc_eq_fail");
 }
 
 impl<'a> VisitOperator<'a> for PrintOperator<'_, '_, '_, '_> {

crates/wast/src/core/binary.rs

@@ -1599,7 +1599,7 @@ impl Encode for BrOnCastFail<'_> {
     }
 }
 
-impl Encode for RefCastDesc<'_> {
+impl Encode for RefCastDescEq<'_> {
     fn encode(&self, e: &mut Vec<u8>) {
         e.push(0xfb);
         if self.r#type.nullable {
@@ -1611,7 +1611,7 @@ impl Encode for RefCastDesc<'_> {
     }
 }
 
-impl Encode for BrOnCastDesc<'_> {
+impl Encode for BrOnCastDescEq<'_> {
     fn encode(&self, e: &mut Vec<u8>) {
         e.push(0xfb);
         e.push(0x25);
@@ -1625,7 +1625,7 @@ impl Encode for BrOnCastDesc<'_> {
     }
 }
 
-impl Encode for BrOnCastDescFail<'_> {
+impl Encode for BrOnCastDescEqFail<'_> {
     fn encode(&self, e: &mut Vec<u8>) {
         e.push(0xfb);
         e.push(0x26);

crates/wast/src/core/expr.rs

@@ -1208,9 +1208,9 @@ instructions! {
         StructNewDesc(Index<'a>) : [0xfb, 32] : "struct.new_desc",
         StructNewDefaultDesc(Index<'a>) : [0xfb, 33] : "struct.new_default_desc",
         RefGetDesc(Index<'a>): [0xfb, 34] : "ref.get_desc",
-        RefCastDesc(RefCastDesc<'a>) : [] : "ref.cast_desc",
-        BrOnCastDesc(Box<BrOnCastDesc<'a>>) : [] : "br_on_cast_desc",
-        BrOnCastDescFail(Box<BrOnCastDescFail<'a>>) : [] : "br_on_cast_desc_fail",
+        RefCastDescEq(RefCastDescEq<'a>) : [] : "ref.cast_desc_eq",
+        BrOnCastDescEq(Box<BrOnCastDescEq<'a>>) : [] : "br_on_cast_desc_eq",
+        BrOnCastDescEqFail(Box<BrOnCastDescEqFail<'a>>) : [] : "br_on_cast_desc_eq_fail",
     }
 }
 
@@ -1974,22 +1974,22 @@ impl<'a> Parse<'a> for BrOnCastFail<'a> {
 
 /// Extra data associated with the `ref.cast_desc` instruction
 #[derive(Debug, Clone)]
-pub struct RefCastDesc<'a> {
+pub struct RefCastDescEq<'a> {
     /// The type to cast to.
     pub r#type: RefType<'a>,
 }
 
-impl<'a> Parse<'a> for RefCastDesc<'a> {
+impl<'a> Parse<'a> for RefCastDescEq<'a> {
     fn parse(parser: Parser<'a>) -> Result<Self> {
-        Ok(RefCastDesc {
+        Ok(RefCastDescEq {
             r#type: parser.parse()?,
         })
     }
 }
 
-/// Extra data associated with the `br_on_cast_desc` instruction
+/// Extra data associated with the `br_on_cast_desc_eq` instruction
 #[derive(Debug, Clone)]
-pub struct BrOnCastDesc<'a> {
+pub struct BrOnCastDescEq<'a> {
     /// The label to branch to.
     pub label: Index<'a>,
     /// The type we're casting from.
@@ -1998,9 +1998,9 @@ pub struct BrOnCastDesc<'a> {
     pub to_type: RefType<'a>,
 }
 
-impl<'a> Parse<'a> for BrOnCastDesc<'a> {
+impl<'a> Parse<'a> for BrOnCastDescEq<'a> {
     fn parse(parser: Parser<'a>) -> Result<Self> {
-        Ok(BrOnCastDesc {
+        Ok(BrOnCastDescEq {
             label: parser.parse()?,
             from_type: parser.parse()?,
             to_type: parser.parse()?,
@@ -2010,7 +2010,7 @@ impl<'a> Parse<'a> for BrOnCastDesc<'a> {
 
 /// Extra data associated with the `br_on_cast_desc_fail` instruction
 #[derive(Debug, Clone)]
-pub struct BrOnCastDescFail<'a> {
+pub struct BrOnCastDescEqFail<'a> {
     /// The label to branch to.
     pub label: Index<'a>,
     /// The type we're casting from.
@@ -2019,9 +2019,9 @@ pub struct BrOnCastDescFail<'a> {
     pub to_type: RefType<'a>,
 }
 
-impl<'a> Parse<'a> for BrOnCastDescFail<'a> {
+impl<'a> Parse<'a> for BrOnCastDescEqFail<'a> {
     fn parse(parser: Parser<'a>) -> Result<Self> {
-        Ok(BrOnCastDescFail {
+        Ok(BrOnCastDescEqFail {
             label: parser.parse()?,
             from_type: parser.parse()?,
             to_type: parser.parse()?,

crates/wast/src/core/resolve/names.rs

@@ -692,15 +692,15 @@ impl<'a, 'b> ExprResolver<'a, 'b> {
             RefGetDesc(i) => {
                 self.resolver.resolve(i, Ns::Type)?;
             }
-            RefCastDesc(i) => {
+            RefCastDescEq(i) => {
                 self.resolver.resolve_reftype(&mut i.r#type)?;
             }
-            BrOnCastDesc(i) => {
+            BrOnCastDescEq(i) => {
                 self.resolve_label(&mut i.label)?;
                 self.resolver.resolve_reftype(&mut i.to_type)?;
                 self.resolver.resolve_reftype(&mut i.from_type)?;
             }
-            BrOnCastDescFail(i) => {
+            BrOnCastDescEqFail(i) => {
                 self.resolve_label(&mut i.label)?;
                 self.resolver.resolve_reftype(&mut i.to_type)?;
                 self.resolver.resolve_reftype(&mut i.from_type)?;