Remove support for variant refines (#2432)

* Remove support for variant `refines`

This was removed from the component model specification a long time ago
and wasm-tools never caught up. Purge the tests and implementation
support for it as it's not needed.

* More fixes

Author: alexcrichton

crates/wasm-compose/src/encoding.rs

@@ -702,9 +702,6 @@ impl<'a> TypeEncoder<'a> {
                 (
                     n.as_str(),
                     c.ty.map(|ty| self.component_val_type(state, ty)),
-                    c.refines
-                        .as_deref()
-                        .map(|r| variant.cases.iter().position(|(n, _)| n == r).unwrap() as u32),
                 )
             })
             .collect::<Vec<_>>();

crates/wasm-encoder/src/component/types.rs

@@ -601,16 +601,16 @@ impl ComponentDefinedTypeEncoder<'_> {
     /// Define a variant type.
     pub fn variant<'a, C>(self, cases: C)
     where
-        C: IntoIterator<Item = (&'a str, Option<ComponentValType>, Option<u32>)>,
+        C: IntoIterator<Item = (&'a str, Option<ComponentValType>)>,
         C::IntoIter: ExactSizeIterator,
     {
         let cases = cases.into_iter();
         self.0.push(0x71);
         cases.len().encode(self.0);
-        for (name, ty, refines) in cases {
+        for (name, ty) in cases {
             name.encode(self.0);
             ty.encode(self.0);
-            refines.encode(self.0);
+            self.0.push(0x00);
         }
     }
 

crates/wasm-encoder/src/reencode/component.rs

@@ -758,13 +758,10 @@ pub mod component_utils {
                 );
             }
             wasmparser::ComponentDefinedType::Variant(v) => {
-                defined.variant(v.iter().map(|case| {
-                    (
-                        case.name,
-                        case.ty.map(|t| reencoder.component_val_type(t)),
-                        case.refines,
-                    )
-                }));
+                defined.variant(
+                    v.iter()
+                        .map(|case| (case.name, case.ty.map(|t| reencoder.component_val_type(t)))),
+                );
             }
             wasmparser::ComponentDefinedType::List(t) => {
                 defined.list(reencoder.component_val_type(t));

crates/wasm-smith/src/component.rs

@@ -1367,14 +1367,7 @@ impl ComponentBuilder {
                 .then(|| self.arbitrary_component_val_type(u))
                 .transpose()?;
 
-            let refines = if !cases.is_empty() && u.arbitrary()? {
-                let max_cases = u32::try_from(cases.len() - 1).unwrap();
-                Some(u.int_in_range(0..=max_cases)?)
-            } else {
-                None
-            };
-
-            cases.push((name, ty, refines));
+            cases.push((name, ty));
             Ok(true)
         })?;
 
@@ -2093,7 +2086,7 @@ struct RecordType {
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 struct VariantType {
-    cases: Vec<(String, Option<ComponentValType>, Option<u32>)>,
+    cases: Vec<(String, Option<ComponentValType>)>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]

crates/wasm-smith/src/component/encode.rs

@@ -229,11 +229,7 @@ impl DefinedType {
                 enc.record(ty.fields.iter().map(|(name, ty)| (name.as_str(), *ty)));
             }
             Self::Variant(ty) => {
-                enc.variant(
-                    ty.cases
-                        .iter()
-                        .map(|(name, ty, refines)| (name.as_str(), *ty, *refines)),
-                );
+                enc.variant(ty.cases.iter().map(|(name, ty)| (name.as_str(), *ty)));
             }
             Self::List(ty) => {
                 enc.list(ty.elem_ty);

crates/wasmparser/src/readers/component/types.rs

@@ -417,21 +417,17 @@ pub struct VariantCase<'a> {
     pub name: &'a str,
     /// The value type of the variant case.
     pub ty: Option<ComponentValType>,
-    /// The index of the variant case that is refined by this one.
-    pub refines: Option<u32>,
 }
 
 impl<'a> FromReader<'a> for VariantCase<'a> {
     fn from_reader(reader: &mut BinaryReader<'a>) -> Result<Self> {
-        Ok(VariantCase {
-            name: reader.read()?,
-            ty: reader.read()?,
-            refines: match reader.read_u8()? {
-                0x0 => None,
-                0x1 => Some(reader.read_var_u32()?),
-                x => return reader.invalid_leading_byte(x, "variant case refines"),
-            },
-        })
+        let name = reader.read()?;
+        let ty = reader.read()?;
+        match reader.read_u8()? {
+            0x0 => {}
+            x => return reader.invalid_leading_byte(x, "zero byte required"),
+        }
+        Ok(VariantCase { name, ty })
     }
 }
 

crates/wasmparser/src/validator/component.rs

@@ -4058,16 +4058,7 @@ impl ComponentState {
             ));
         }
 
-        for (i, case) in cases.iter().enumerate() {
-            if let Some(refines) = case.refines {
-                if refines >= i as u32 {
-                    return Err(BinaryReaderError::new(
-                        "variant case can only refine a previously defined case",
-                        offset,
-                    ));
-                }
-            }
-
+        for case in cases {
             let name = to_kebab_str(case.name, "variant case", offset)?;
 
             let ty = case
@@ -4086,15 +4077,7 @@ impl ComponentState {
                     if let Some(ty) = ty {
                         info.combine(ty.info(types), offset)?;
                     }
-
-                    // Safety: the use of `KebabStr::new_unchecked` here is safe because the string
-                    // was already verified to be kebab case.
-                    e.insert(VariantCase {
-                        ty,
-                        refines: case
-                            .refines
-                            .map(|i| KebabStr::new_unchecked(cases[i as usize].name).to_owned()),
-                    });
+                    e.insert(VariantCase { ty });
                 }
             }
         }

crates/wasmparser/src/validator/component_types.rs

@@ -1346,8 +1346,6 @@ impl ComponentFuncType {
 pub struct VariantCase {
     /// The variant case type.
     pub ty: Option<ComponentValType>,
-    /// The name of the variant case refined by this one.
-    pub refines: Option<KebabString>,
 }
 
 /// Represents a record type.

crates/wasmprinter/src/component.rs

@@ -145,12 +145,6 @@ impl Printer<'_, '_> {
                 self.print_component_val_type(state, &ty)?;
             }
 
-            if let Some(refines) = case.refines {
-                self.result.write_str(" ")?;
-                self.start_group("refines ")?;
-                write!(&mut self.result, "{refines}")?;
-                self.end_group()?;
-            }
             self.end_group()?;
         }
         self.end_group()?;

crates/wast/src/component/binary.rs

@@ -98,13 +98,11 @@ fn encode_defined_type(encoder: ComponentDefinedTypeEncoder, ty: &ComponentDefin
             encoder.record(r.fields.iter().map(|f| (f.name, &f.ty)));
         }
         ComponentDefinedType::Variant(v) => {
-            encoder.variant(v.cases.iter().map(|c| {
-                (
-                    c.name,
-                    c.ty.as_ref().map(Into::into),
-                    c.refines.as_ref().map(Into::into),
-                )
-            }));
+            encoder.variant(
+                v.cases
+                    .iter()
+                    .map(|c| (c.name, c.ty.as_ref().map(Into::into))),
+            );
         }
         ComponentDefinedType::List(l) => {
             encoder.list(l.element.as_ref());
@@ -827,15 +825,6 @@ impl From<PrimitiveValType> for wasm_encoder::PrimitiveValType {
     }
 }
 
-impl From<&Refinement<'_>> for u32 {
-    fn from(r: &Refinement) -> Self {
-        match r {
-            Refinement::Index(..) => unreachable!("should be resolved by now"),
-            Refinement::Resolved(i) => *i,
-        }
-    }
-}
-
 impl From<&ItemSigKind<'_>> for wasm_encoder::ComponentTypeRef {
     fn from(k: &ItemSigKind) -> Self {
         match k {