Implement reference-types Wasm proposal

crates/arena/src/lib.rs

@@ -32,7 +32,6 @@ mod tests;
 pub use self::{component_vec::ComponentVec, dedup::DedupArena, guarded::GuardedEntity};
 use alloc::vec::Vec;
 use core::{
-    cmp::max,
     iter::{DoubleEndedIterator, Enumerate, ExactSizeIterator},
     marker::PhantomData,
     ops::{Index, IndexMut},
@@ -159,8 +158,15 @@ where
     pub fn get_pair_mut(&mut self, fst: Idx, snd: Idx) -> Option<(&mut T, &mut T)> {
         let fst_index = fst.into_usize();
         let snd_index = snd.into_usize();
-        let max_index = max(fst_index, snd_index);
-        let (fst_set, snd_set) = self.entities.split_at_mut(max_index);
+        if fst_index == snd_index {
+            return None;
+        }
+        if fst_index > snd_index {
+            let (fst, snd) = self.get_pair_mut(snd, fst)?;
+            return Some((snd, fst));
+        }
+        // At this point we know that fst_index < snd_index.
+        let (fst_set, snd_set) = self.entities.split_at_mut(snd_index);
         let fst = fst_set.get_mut(fst_index)?;
         let snd = snd_set.get_mut(0)?;
         Some((fst, snd))

crates/cli/src/main.rs

@@ -1,8 +1,8 @@
 use anyhow::{anyhow, bail, Result};
 use clap::Parser;
-use core::fmt::Write;
 use std::{
     ffi::OsStr,
+    fmt::{self, Write},
     fs,
     path::{Path, PathBuf},
 };
@@ -221,8 +221,9 @@ fn type_check_arguments(
 ) -> Result<Vec<Value>> {
     if func_type.params().len() != func_args.len() {
         bail!(
-            "invalid number of arguments given for {func_name} of type {func_type}. \
+            "invalid number of arguments given for {func_name} of type {}. \
             expected {} argument but got {}",
+            DisplayFuncType(func_type),
             func_type.params().len(),
             func_args.len()
         );
@@ -256,6 +257,12 @@ fn type_check_arguments(
                     .map(F64::from)
                     .map(Value::from)
                     .map_err(make_err!()),
+                ValueType::FuncRef => {
+                    bail!("the wasmi CLI cannot take arguments of type funcref")
+                }
+                ValueType::ExternRef => {
+                    bail!("the wasmi CLI cannot take arguments of type externref")
+                }
             }
         })
         .collect::<Result<Vec<_>, _>>()?;
@@ -276,17 +283,39 @@ fn prepare_results_buffer(func_type: &FuncType) -> Vec<Value> {
 fn print_execution_start(wasm_file: &Path, func_name: &str, func_args: &[Value]) {
     print!("executing {wasm_file:?}::{func_name}(");
     if let Some((first_arg, rest_args)) = func_args.split_first() {
-        print!("{first_arg}");
-        for arg in rest_args {
+        print!("{}", DisplayValue(first_arg));
+        for arg in rest_args.iter().map(DisplayValue) {
             print!(", {arg}");
         }
     }
     println!(") ...");
 }
 
+/// Wrapper type that implements `Display` for [`Value`].
+struct DisplayValue<'a>(&'a Value);
+
+impl<'a> fmt::Display for DisplayValue<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match &self.0 {
+            Value::I32(value) => write!(f, "{value}"),
+            Value::I64(value) => write!(f, "{value}"),
+            Value::F32(value) => write!(f, "{value}"),
+            Value::F64(value) => write!(f, "{value}"),
+            Value::FuncRef(value) => panic!("cannot display funcref values but found {value:?}"),
+            Value::ExternRef(value) => {
+                panic!("cannot display externref values but found {value:?}")
+            }
+        }
+    }
+}
+
 /// Prints the results of the Wasm computation in a human readable form.
 fn print_pretty_results(results: &[Value]) {
-    let pretty_results = results.iter().map(Value::to_string).collect::<Vec<_>>();
+    let pretty_results = results
+        .iter()
+        .map(DisplayValue)
+        .map(|v| v.to_string())
+        .collect::<Vec<_>>();
     match pretty_results.len() {
         1 => {
             println!("{}", pretty_results[0]);
@@ -303,3 +332,133 @@ fn print_pretty_results(results: &[Value]) {
         }
     }
 }
+
+/// Wrapper type around [`FuncType`] that implements `Display` for it.
+struct DisplayFuncType<'a>(&'a FuncType);
+
+impl fmt::Display for DisplayFuncType<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "fn(")?;
+        let params = self.0.params();
+        let results = self.0.results();
+        write_slice(f, params, ",")?;
+        write!(f, ")")?;
+        if let Some((first, rest)) = results.split_first() {
+            write!(f, " -> ")?;
+            if !rest.is_empty() {
+                write!(f, "(")?;
+            }
+            write!(f, "{first}")?;
+            for result in rest {
+                write!(f, ", {result}")?;
+            }
+            if !rest.is_empty() {
+                write!(f, ")")?;
+            }
+        }
+        Ok(())
+    }
+}
+
+/// Writes the elements of a `slice` separated by the `separator`.
+fn write_slice<T>(f: &mut fmt::Formatter, slice: &[T], separator: &str) -> fmt::Result
+where
+    T: fmt::Display,
+{
+    if let Some((first, rest)) = slice.split_first() {
+        write!(f, "{first}")?;
+        for param in rest {
+            write!(f, "{separator} {param}")?;
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use core::borrow::Borrow;
+
+    fn assert_display(func_type: impl Borrow<FuncType>, expected: &str) {
+        assert_eq!(
+            format!("{}", DisplayFuncType(func_type.borrow())),
+            String::from(expected),
+        );
+    }
+
+    #[test]
+    fn display_0in_0out() {
+        assert_display(FuncType::new([], []), "fn()");
+    }
+
+    #[test]
+    fn display_1in_0out() {
+        assert_display(FuncType::new([ValueType::I32], []), "fn(i32)");
+    }
+
+    #[test]
+    fn display_0in_1out() {
+        assert_display(FuncType::new([], [ValueType::I32]), "fn() -> i32");
+    }
+
+    #[test]
+    fn display_1in_1out() {
+        assert_display(
+            FuncType::new([ValueType::I32], [ValueType::I32]),
+            "fn(i32) -> i32",
+        );
+    }
+
+    #[test]
+    fn display_4in_0out() {
+        assert_display(
+            FuncType::new(
+                [
+                    ValueType::I32,
+                    ValueType::I64,
+                    ValueType::F32,
+                    ValueType::F64,
+                ],
+                [],
+            ),
+            "fn(i32, i64, f32, f64)",
+        );
+    }
+
+    #[test]
+    fn display_0in_4out() {
+        assert_display(
+            FuncType::new(
+                [],
+                [
+                    ValueType::I32,
+                    ValueType::I64,
+                    ValueType::F32,
+                    ValueType::F64,
+                ],
+            ),
+            "fn() -> (i32, i64, f32, f64)",
+        );
+    }
+
+    #[test]
+    fn display_4in_4out() {
+        assert_display(
+            FuncType::new(
+                [
+                    ValueType::I32,
+                    ValueType::I64,
+                    ValueType::F32,
+                    ValueType::F64,
+                ],
+                [
+                    ValueType::I32,
+                    ValueType::I64,
+                    ValueType::F32,
+                    ValueType::F64,
+                ],
+            ),
+            "fn(i32, i64, f32, f64) -> (i32, i64, f32, f64)",
+        );
+    }
+}

crates/core/src/trap.rs

@@ -243,10 +243,10 @@ impl TrapCode {
     /// other uses since it avoid heap memory allocation in certain cases.
     pub fn trap_message(&self) -> &'static str {
         match self {
-            Self::UnreachableCodeReached => "unreachable",
+            Self::UnreachableCodeReached => "wasm `unreachable` instruction executed",
             Self::MemoryOutOfBounds => "out of bounds memory access",
-            Self::TableOutOfBounds => "undefined element",
-            Self::IndirectCallToNull => "uninitialized element",
+            Self::TableOutOfBounds => "undefined element: out of bounds table access",
+            Self::IndirectCallToNull => "uninitialized element 2", // TODO: fixme, remove the trailing " 2" again
             Self::IntegerDivisionByZero => "integer divide by zero",
             Self::IntegerOverflow => "integer overflow",
             Self::BadConversionToInteger => "invalid conversion to integer",

crates/core/src/value.rs

@@ -19,6 +19,27 @@ pub enum ValueType {
     F32,
     /// 64-bit IEEE 754-2008 floating point number.
     F64,
+    /// A nullable function reference.
+    FuncRef,
+    /// A nullable external reference.
+    ExternRef,
+}
+
+impl ValueType {
+    /// Returns `true` if [`ValueType`] is a Wasm numeric type.
+    ///
+    /// This is `true` for [`ValueType::I32`], [`ValueType::I64`],
+    /// [`ValueType::F32`] and [`ValueType::F64`].
+    pub fn is_num(&self) -> bool {
+        matches!(self, Self::I32 | Self::I64 | Self::F32 | Self::F64)
+    }
+
+    /// Returns `true` if [`ValueType`] is a Wasm reference type.
+    ///
+    /// This is `true` for [`ValueType::FuncRef`] and [`ValueType::ExternRef`].
+    pub fn is_ref(&self) -> bool {
+        matches!(self, Self::ExternRef | Self::FuncRef)
+    }
 }
 
 impl Display for ValueType {
@@ -28,6 +49,8 @@ impl Display for ValueType {
             Self::I64 => write!(f, "i64"),
             Self::F32 => write!(f, "f32"),
             Self::F64 => write!(f, "f64"),
+            Self::FuncRef => write!(f, "funcref"),
+            Self::ExternRef => write!(f, "externref"),
         }
     }
 }