Turn WasmFeatures into a bitflags type (#1496)

* turn WasmFeatures into a bitflags type

* applied code review suggestions

* apply rustfmt

* refactor parse_features as requested

Author: Robbepop

Cargo.toml

@@ -58,6 +58,7 @@ pretty_assertions = "1.3.0"
 semver = "1.0.0"
 smallvec = "1.11.1"
 libtest-mimic = "0.7.0"
+bitflags = "2.5.0"
 
 wasm-compose = { version = "0.203.0", path = "crates/wasm-compose" }
 wasm-encoder = { version = "0.203.0", path = "crates/wasm-encoder" }

crates/wasm-compose/src/graph.rs

@@ -98,10 +98,8 @@ impl<'a> Component<'a> {
     fn parse(name: String, path: Option<PathBuf>, bytes: Cow<'a, [u8]>) -> Result<Self> {
         let mut parser = Parser::new(0);
         let mut parsers = Vec::new();
-        let mut validator = Validator::new_with_features(WasmFeatures {
-            component_model: true,
-            ..Default::default()
-        });
+        let mut validator =
+            Validator::new_with_features(WasmFeatures::default() | WasmFeatures::COMPONENT_MODEL);
         let mut imports = IndexMap::new();
         let mut exports = IndexMap::new();
 
@@ -992,12 +990,9 @@ impl<'a> CompositionGraph<'a> {
         let bytes = CompositionGraphEncoder::new(options, self).encode()?;
 
         if options.validate {
-            Validator::new_with_features(WasmFeatures {
-                component_model: true,
-                ..Default::default()
-            })
-            .validate_all(&bytes)
-            .context("failed to validate encoded graph bytes")?;
+            Validator::new_with_features(WasmFeatures::default() | WasmFeatures::COMPONENT_MODEL)
+                .validate_all(&bytes)
+                .context("failed to validate encoded graph bytes")?;
         }
 
         Ok(bytes)

crates/wasm-compose/tests/compose.rs

@@ -82,17 +82,14 @@ fn component_composing() -> Result<()> {
             let bytes =
                 r.with_context(|| format!("failed to encode for test case `{}`", test_case))?;
 
-            Validator::new_with_features(WasmFeatures {
-                component_model: true,
-                ..Default::default()
-            })
-            .validate_all(&bytes)
-            .with_context(|| {
-                format!(
-                    "failed to validate component bytes for test case `{}`",
-                    test_case
-                )
-            })?;
+            Validator::new_with_features(WasmFeatures::default() | WasmFeatures::COMPONENT_MODEL)
+                .validate_all(&bytes)
+                .with_context(|| {
+                    format!(
+                        "failed to validate component bytes for test case `{}`",
+                        test_case
+                    )
+                })?;
 
             wit_component::decode(&bytes).with_context(|| {
                 format!(

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

@@ -650,6 +650,8 @@ impl Section for TypeSection {
 
 #[cfg(test)]
 mod tests {
+    use wasmparser::WasmFeatures;
+
     use super::*;
     use crate::Module;
 
@@ -666,10 +668,8 @@ mod tests {
         module.section(&types);
         let wasm_bytes = module.finish();
 
-        let mut validator = wasmparser::Validator::new_with_features(wasmparser::WasmFeatures {
-            gc: false,
-            ..Default::default()
-        });
+        let mut validator =
+            wasmparser::Validator::new_with_features(WasmFeatures::default() & !WasmFeatures::GC);
 
         validator.validate_all(&wasm_bytes).expect(
             "Encoding pre Wasm GC type should not accidentally use Wasm GC specific encoding",

crates/wasm-mutate/src/lib.rs

@@ -320,11 +320,11 @@ impl<'wasm> WasmMutate<'wasm> {
 
 #[cfg(test)]
 pub(crate) fn validate(bytes: &[u8]) {
-    let mut validator = wasmparser::Validator::new_with_features(wasmparser::WasmFeatures {
-        memory64: true,
-        multi_memory: true,
-        ..Default::default()
-    });
+    use wasmparser::WasmFeatures;
+
+    let mut validator = wasmparser::Validator::new_with_features(
+        WasmFeatures::default() | WasmFeatures::MEMORY64 | WasmFeatures::MULTI_MEMORY,
+    );
     let err = match validator.validate_all(bytes) {
         Ok(_) => return,
         Err(e) => e,

crates/wasm-shrink/src/lib.rs

@@ -8,6 +8,7 @@ use std::collections::HashSet;
 use anyhow::{Context, Result};
 use rand::{rngs::SmallRng, Rng, SeedableRng};
 use wasm_mutate::WasmMutate;
+use wasmparser::WasmFeatures;
 
 #[rustfmt::skip]
 static EMPTY_WASM: &'static [u8] = &[
@@ -216,33 +217,24 @@ impl ShrinkRun {
     }
 
     fn validate_wasm(&self, wasm: &[u8]) -> Result<()> {
-        let mut validator = wasmparser::Validator::new_with_features(wasmparser::WasmFeatures {
-            // TODO: we should have CLI flags for each Wasm proposal.
-            reference_types: true,
-            multi_value: true,
-            bulk_memory: true,
-            simd: true,
-            threads: true,
-            shared_everything_threads: false,
-            tail_call: true,
-            multi_memory: true,
-            exceptions: true,
-            memory64: true,
-            relaxed_simd: true,
-            extended_const: true,
-            mutable_global: true,
-            saturating_float_to_int: true,
-            sign_extension: true,
-            component_model: false,
-            function_references: false,
-            gc: false,
-            custom_page_sizes: false,
-            component_model_values: false,
-            component_model_nested_names: false,
-
-            floats: true,
-            memory_control: true,
-        });
+        let mut validator = wasmparser::Validator::new_with_features(
+            WasmFeatures::REFERENCE_TYPES
+                | WasmFeatures::MULTI_VALUE
+                | WasmFeatures::BULK_MEMORY
+                | WasmFeatures::SIMD
+                | WasmFeatures::THREADS
+                | WasmFeatures::TAIL_CALL
+                | WasmFeatures::MULTI_MEMORY
+                | WasmFeatures::EXCEPTIONS
+                | WasmFeatures::MEMORY64
+                | WasmFeatures::RELAXED_SIMD
+                | WasmFeatures::EXTENDED_CONST
+                | WasmFeatures::MUTABLE_GLOBAL
+                | WasmFeatures::SATURATING_FLOAT_TO_INT
+                | WasmFeatures::SIGN_EXTENSION
+                | WasmFeatures::FLOATS
+                | WasmFeatures::MEMORY_CONTROL,
+        );
 
         validator.validate_all(wasm)?;
         Ok(())

crates/wasm-smith/tests/common/mod.rs

@@ -2,32 +2,34 @@ use wasm_smith::Config;
 use wasmparser::{types::Types, Validator, WasmFeatures};
 
 pub fn parser_features_from_config(config: &Config) -> WasmFeatures {
-    WasmFeatures {
-        mutable_global: true,
-        saturating_float_to_int: config.saturating_float_to_int_enabled,
-        sign_extension: config.sign_extension_ops_enabled,
-        reference_types: config.reference_types_enabled,
-        multi_value: config.multi_value_enabled,
-        bulk_memory: config.bulk_memory_enabled,
-        simd: config.simd_enabled,
-        relaxed_simd: config.relaxed_simd_enabled,
-        multi_memory: config.max_memories > 1,
-        exceptions: config.exceptions_enabled,
-        memory64: config.memory64_enabled,
-        tail_call: config.tail_call_enabled,
-        function_references: config.gc_enabled,
-        gc: config.gc_enabled,
-        custom_page_sizes: config.custom_page_sizes_enabled,
-
-        threads: false,
-        shared_everything_threads: false,
-        floats: true,
-        extended_const: false,
-        component_model: false,
-        memory_control: false,
-        component_model_values: false,
-        component_model_nested_names: false,
-    }
+    let mut features = WasmFeatures::MUTABLE_GLOBAL | WasmFeatures::FLOATS;
+    features.set(
+        WasmFeatures::SATURATING_FLOAT_TO_INT,
+        config.saturating_float_to_int_enabled,
+    );
+    features.set(
+        WasmFeatures::SIGN_EXTENSION,
+        config.sign_extension_ops_enabled,
+    );
+    features.set(
+        WasmFeatures::REFERENCE_TYPES,
+        config.reference_types_enabled,
+    );
+    features.set(WasmFeatures::MULTI_VALUE, config.multi_value_enabled);
+    features.set(WasmFeatures::BULK_MEMORY, config.bulk_memory_enabled);
+    features.set(WasmFeatures::SIMD, config.simd_enabled);
+    features.set(WasmFeatures::RELAXED_SIMD, config.relaxed_simd_enabled);
+    features.set(WasmFeatures::MULTI_MEMORY, config.max_memories > 1);
+    features.set(WasmFeatures::EXCEPTIONS, config.exceptions_enabled);
+    features.set(WasmFeatures::MEMORY64, config.memory64_enabled);
+    features.set(WasmFeatures::TAIL_CALL, config.tail_call_enabled);
+    features.set(WasmFeatures::FUNCTION_REFERENCES, config.gc_enabled);
+    features.set(WasmFeatures::GC, config.gc_enabled);
+    features.set(
+        WasmFeatures::CUSTOM_PAGE_SIZE,
+        config.custom_page_sizes_enabled,
+    );
+    features
 }
 
 pub fn validate(validator: &mut Validator, bytes: &[u8]) -> Types {

crates/wasm-smith/tests/component.rs

@@ -18,11 +18,9 @@ fn smoke_test_component() {
             ok_count += 1;
             let component = component.to_bytes();
 
-            let mut validator =
-                wasmparser::Validator::new_with_features(wasmparser::WasmFeatures {
-                    component_model: true,
-                    ..Default::default()
-                });
+            let mut validator = wasmparser::Validator::new_with_features(
+                wasmparser::WasmFeatures::default() | wasmparser::WasmFeatures::COMPONENT_MODEL,
+            );
             if let Err(e) = validator.validate_all(&component) {
                 std::fs::write("component.wasm", &component).unwrap();
                 panic!(

crates/wasm-smith/tests/core.rs

@@ -69,7 +69,7 @@ fn multi_value_disabled() {
         if let Ok(module) = Module::new(cfg, &mut u) {
             let wasm_bytes = module.to_bytes();
             let mut features = wasm_features();
-            features.multi_value = false;
+            features.remove(WasmFeatures::MULTI_VALUE);
             let mut validator = Validator::new_with_features(features);
             validate(&mut validator, &wasm_bytes);
         }
@@ -143,14 +143,5 @@ fn smoke_test_wasm_gc() {
 }
 
 fn wasm_features() -> WasmFeatures {
-    WasmFeatures {
-        multi_memory: true,
-        relaxed_simd: true,
-        memory64: true,
-        exceptions: true,
-        tail_call: true,
-        function_references: true,
-        gc: true,
-        ..WasmFeatures::default()
-    }
+    WasmFeatures::all()
 }