fix: add ConstExpr::evaluate_scalar and expand spec test coverage

crates/tests/build.rs

@@ -10,11 +10,7 @@ fn is_known_failing(name: &str) -> bool {
         "tests_spec_tests_legacy_rethrow_wast"
         | "tests_spec_tests_legacy_throw_wast"
         | "tests_spec_tests_legacy_try_catch_wast"
-        | "tests_spec_tests_legacy_try_delegate_wast"
-        // 64-bit memory/table offsets not yet supported in walrus.
-        | "tests_spec_tests_data_wast"  // active data with non-i32 offset (memory64)
-        | "tests_spec_tests_elem_wast"  // active elem with non-i32 offset (table64)
-        => true,
+        | "tests_spec_tests_legacy_try_delegate_wast" => true,
 
         _ => false,
     }

crates/tests/tests/spec-tests.rs

@@ -23,20 +23,22 @@ fn run(wast: &Path) -> Result<(), anyhow::Error> {
         .nth(1)
         .map(|s| s.to_str().unwrap());
 
+    // The custom/ directory contains annotation syntax tests that wasm-tools
+    // json-from-wast does not yet support.
+    let in_custom_dir = wast.iter().any(|p| p == "custom");
+    if in_custom_dir {
+        return Ok(());
+    }
+
     let extra_args: &[&str] = match proposal {
         None => &[],
-        Some("annotations") => return Ok(()),
+        // The threads proposal testsuite has stale assert_invalid cases for
+        // multiple tables that predate the reference-types proposal.
+        Some("threads") => return Ok(()),
+        // custom-descriptors and custom-page-sizes are not yet supported
         Some("custom-descriptors") => return Ok(()),
         Some("custom-page-sizes") => return Ok(()),
-        Some("exception-handling") => &[],
-        Some("extended-const") => &[],
-        Some("function-references") => &[],
-        Some("gc") => return Ok(()),
-        Some("relaxed-simd") => &[],
-        Some("tail-call") => &[],
-        Some("threads") => return Ok(()),
-        Some("wide-arithmetic") => &[],
-        Some(other) => bail!("unknown wasm proposal: {}", other),
+        Some(_) => &[],
     };
 
     let tempdir = TempDir::new()?;

src/const_expr.rs

@@ -79,6 +79,86 @@ pub enum ConstOp {
 }
 
 impl ConstExpr {
+    /// Attempt to statically evaluate this expression to a [`Value`].
+    ///
+    /// `resolve_global` is called to obtain the initialiser `ConstExpr` for a
+    /// global; return `None` for imported globals whose value is not known at
+    /// compile time.  The method returns `None` whenever the expression cannot
+    /// be fully reduced (unknown global, non-numeric opcode, etc.).
+    pub fn evaluate_scalar<F>(&self, resolve_global: &F) -> Option<Value>
+    where
+        F: Fn(GlobalId) -> Option<ConstExpr>,
+    {
+        match self {
+            ConstExpr::Value(v) => Some(*v),
+            ConstExpr::Global(g) => resolve_global(*g)?.evaluate_scalar(resolve_global),
+            ConstExpr::Extended(ops) => {
+                let mut stack: Vec<Value> = Vec::new();
+                for op in ops {
+                    match op {
+                        ConstOp::I32Const(n) => stack.push(Value::I32(*n)),
+                        ConstOp::I64Const(n) => stack.push(Value::I64(*n)),
+                        ConstOp::F32Const(n) => stack.push(Value::F32(*n)),
+                        ConstOp::F64Const(n) => stack.push(Value::F64(*n)),
+                        ConstOp::V128Const(n) => stack.push(Value::V128(*n)),
+                        ConstOp::GlobalGet(g) => {
+                            stack.push(resolve_global(*g)?.evaluate_scalar(resolve_global)?);
+                        }
+                        ConstOp::I32Add => {
+                            let (Value::I32(b), Value::I32(a)) = (stack.pop()?, stack.pop()?)
+                            else {
+                                return None;
+                            };
+                            stack.push(Value::I32(a.wrapping_add(b)));
+                        }
+                        ConstOp::I32Sub => {
+                            let (Value::I32(b), Value::I32(a)) = (stack.pop()?, stack.pop()?)
+                            else {
+                                return None;
+                            };
+                            stack.push(Value::I32(a.wrapping_sub(b)));
+                        }
+                        ConstOp::I32Mul => {
+                            let (Value::I32(b), Value::I32(a)) = (stack.pop()?, stack.pop()?)
+                            else {
+                                return None;
+                            };
+                            stack.push(Value::I32(a.wrapping_mul(b)));
+                        }
+                        ConstOp::I64Add => {
+                            let (Value::I64(b), Value::I64(a)) = (stack.pop()?, stack.pop()?)
+                            else {
+                                return None;
+                            };
+                            stack.push(Value::I64(a.wrapping_add(b)));
+                        }
+                        ConstOp::I64Sub => {
+                            let (Value::I64(b), Value::I64(a)) = (stack.pop()?, stack.pop()?)
+                            else {
+                                return None;
+                            };
+                            stack.push(Value::I64(a.wrapping_sub(b)));
+                        }
+                        ConstOp::I64Mul => {
+                            let (Value::I64(b), Value::I64(a)) = (stack.pop()?, stack.pop()?)
+                            else {
+                                return None;
+                            };
+                            stack.push(Value::I64(a.wrapping_mul(b)));
+                        }
+                        _ => return None,
+                    }
+                }
+                if stack.len() == 1 {
+                    stack.pop()
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        }
+    }
+
     pub(crate) fn eval(init: &wasmparser::ConstExpr, ids: &IndicesToIds) -> Result<ConstExpr> {
         use wasmparser::Operator::*;
         let mut reader = init.get_operators_reader();