A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
//! This module generates test cases for the Wasmtime component model function APIs,
//! e.g. `wasmtime::component::func::Func` and `TypedFunc`.
//!
//! Each case includes a list of arbitrary interface types to use as parameters, plus another one to use as a
//! result, and a component which exports a function and imports a function. The exported function forwards its
//! parameters to the imported one and forwards the result back to the caller. This serves to exercise Wasmtime's
//! lifting and lowering code and verify the values remain intact during both processes.
use arbitrary::{Arbitrary, Unstructured};
use indexmap::IndexSet;
use proc_macro2::{Ident, TokenStream};
use quote::{ToTokens, format_ident, quote};
use std::borrow::Cow;
use std::fmt::{self, Debug, Write};
use std::hash::{Hash, Hasher};
use std::iter;
use std::ops::Deref;
use wasmtime_component_util::{DiscriminantSize, FlagsSize, REALLOC_AND_FREE};
const MAX_FLAT_PARAMS: usize = 16;
const MAX_FLAT_ASYNC_PARAMS: usize = 4;
const MAX_FLAT_RESULTS: usize = 1;
/// The name of the imported host function which the generated component will call
pub const IMPORT_FUNCTION: &str = "echo-import";
/// The name of the exported guest function which the host should call
pub const EXPORT_FUNCTION: &str = "echo-export";
/// Wasmtime allows up to 100 type depth so limit this to just under that.
pub const MAX_TYPE_DEPTH: u32 = 90;
macro_rules! uwriteln {
($($arg:tt)*) => {
writeln!($($arg)*).unwrap()
};
}
macro_rules! uwrite {
($($arg:tt)*) => {
write!($($arg)*).unwrap()
};
}
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
enum CoreType {
I32,
I64,
F32,
F64,
}
impl CoreType {
/// This is the `join` operation specified in [the canonical
/// ABI](https://github.com/WebAssembly/component-model/blob/main/design/mvp/CanonicalABI.md#flattening) for
/// variant types.
fn join(self, other: Self) -> Self {
match (self, other) {
_ if self == other => self,
(Self::I32, Self::F32) | (Self::F32, Self::I32) => Self::I32,
_ => Self::I64,
}
}
}
impl fmt::Display for CoreType {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::I32 => f.write_str("i32"),
Self::I64 => f.write_str("i64"),
Self::F32 => f.write_str("f32"),
Self::F64 => f.write_str("f64"),
}
}
}
/// Wraps a `Box<[T]>` and provides an `Arbitrary` implementation that always generates slices of length less than
/// or equal to the longest tuple for which Wasmtime generates a `ComponentType` impl
#[derive(Debug, Clone)]
pub struct VecInRange<T, const L: u32, const H: u32>(Vec<T>);
impl<T, const L: u32, const H: u32> VecInRange<T, L, H> {
fn new<'a>(
input: &mut Unstructured<'a>,
fuel: &mut u32,
generate: impl Fn(&mut Unstructured<'a>, &mut u32) -> arbitrary::Result<T>,
) -> arbitrary::Result<Self> {
let mut ret = Vec::new();
input.arbitrary_loop(Some(L), Some(H), |input| {
if *fuel > 0 {
*fuel = *fuel - 1;
ret.push(generate(input, fuel)?);
Ok(std::ops::ControlFlow::Continue(()))
} else {
Ok(std::ops::ControlFlow::Break(()))
}
})?;
Ok(Self(ret))
}
}
impl<T, const L: u32, const H: u32> Deref for VecInRange<T, L, H> {
type Target = [T];
fn deref(&self) -> &[T] {
self.0.deref()
}
}
/// Represents a component model interface type
#[expect(missing_docs, reason = "self-describing")]
#[derive(Debug, Clone)]
pub enum Type {
Bool,
S8,
U8,
S16,
U16,
S32,
U32,
S64,
U64,
Float32,
Float64,
Char,
String,
List(Box<Type>),
Map(Box<Type>, Box<Type>),
// Give records the ability to generate a generous amount of fields but
// don't let the fuzzer go too wild since `wasmparser`'s validator currently
// has hard limits in the 1000-ish range on the number of fields a record
// may contain.
Record(VecInRange<Type, 1, 200>),
// Tuples can only have up to 16 type parameters in wasmtime right now for
// the static API, but the standard library only supports `Debug` up to 11
// elements, so compromise at an even 10.
Tuple(VecInRange<Type, 1, 10>),
// Like records, allow a good number of variants, but variants require at
// least one case.
Variant(VecInRange<Option<Type>, 1, 200>),
Enum(u32),
Option(Box<Type>),
Result {
ok: Option<Box<Type>>,
err: Option<Box<Type>>,
},
Flags(u32),
}
impl Type {
pub fn generate(
u: &mut Unstructured<'_>,
depth: u32,
fuel: &mut u32,
) -> arbitrary::Result<Type> {
*fuel = fuel.saturating_sub(1);
let max = if depth == 0 || *fuel == 0 { 12 } else { 21 };
Ok(match u.int_in_range(0..=max)? {
0 => Type::Bool,
1 => Type::S8,
2 => Type::U8,
3 => Type::S16,
4 => Type::U16,
5 => Type::S32,
6 => Type::U32,
7 => Type::S64,
8 => Type::U64,
9 => Type::Float32,
10 => Type::Float64,
11 => Type::Char,
12 => Type::String,
// ^-- if you add something here update the `depth == 0` case above
13 => Type::List(Box::new(Type::generate(u, depth - 1, fuel)?)),
14 => Type::Record(Type::generate_list(u, depth - 1, fuel)?),
15 => Type::Tuple(Type::generate_list(u, depth - 1, fuel)?),
16 => Type::Variant(VecInRange::new(u, fuel, |u, fuel| {
Type::generate_opt(u, depth - 1, fuel)
})?),
17 => {
let amt = u.int_in_range(1..=(*fuel).max(1).min(257))?;
*fuel -= amt;
Type::Enum(amt)
}
18 => Type::Option(Box::new(Type::generate(u, depth - 1, fuel)?)),
19 => Type::Result {
ok: Type::generate_opt(u, depth - 1, fuel)?.map(Box::new),
err: Type::generate_opt(u, depth - 1, fuel)?.map(Box::new),
},
20 => {
let amt = u.int_in_range(1..=(*fuel).min(32))?;
*fuel -= amt;
Type::Flags(amt)
}
21 => Type::Map(
Box::new(Type::generate_hashable_key(u, fuel)?),
Box::new(Type::generate(u, depth - 1, fuel)?),
),
// ^-- if you add something here update the `depth != 0` case above
_ => unreachable!(),
})
}
/// Generate a type that can be used as a HashMap key (implements Hash + Eq).
/// This excludes floats and complex types that might contain floats.
fn generate_hashable_key(u: &mut Unstructured<'_>, fuel: &mut u32) -> arbitrary::Result<Type> {
*fuel = fuel.saturating_sub(1);
// Only generate types that implement Hash and Eq:
// - No Float32/Float64 (NaN comparison issues)
// - No complex types (Record, Tuple, Variant, etc.) as they might contain floats
// - String is allowed as it implements Hash + Eq
Ok(match u.int_in_range(0..=10)? {
0 => Type::Bool,
1 => Type::S8,
2 => Type::U8,
3 => Type::S16,
4 => Type::U16,
5 => Type::S32,
6 => Type::U32,
7 => Type::S64,
8 => Type::U64,
9 => Type::Char,
10 => Type::String,
_ => unreachable!(),
})
}
fn generate_opt(
u: &mut Unstructured<'_>,
depth: u32,
fuel: &mut u32,
) -> arbitrary::Result<Option<Type>> {
Ok(if u.arbitrary()? {
Some(Type::generate(u, depth, fuel)?)
} else {
None
})
}
fn generate_list<const L: u32, const H: u32>(
u: &mut Unstructured<'_>,
depth: u32,
fuel: &mut u32,
) -> arbitrary::Result<VecInRange<Type, L, H>> {
VecInRange::new(u, fuel, |u, fuel| Type::generate(u, depth, fuel))
}
/// Generates text format wasm into `s` to store a value of this type, in
/// its flat representation stored in the `locals` provided, to the local
/// named `ptr` at the `offset` provided.
///
/// This will register helper functions necessary in `helpers`. The
/// `locals` iterator will be advanced for all locals consumed by this
/// store operation.
fn store_flat<'a>(
&'a self,
s: &mut String,
ptr: &str,
offset: u32,
locals: &mut dyn Iterator<Item = FlatSource>,
helpers: &mut IndexSet<Helper<'a>>,
) {
enum Kind {
Primitive(&'static str),
PointerPair,
Helper,
}
let kind = match self {
Type::Bool | Type::S8 | Type::U8 => Kind::Primitive("i32.store8"),
Type::S16 | Type::U16 => Kind::Primitive("i32.store16"),
Type::S32 | Type::U32 | Type::Char => Kind::Primitive("i32.store"),
Type::S64 | Type::U64 => Kind::Primitive("i64.store"),
Type::Float32 => Kind::Primitive("f32.store"),
Type::Float64 => Kind::Primitive("f64.store"),
Type::String | Type::List(_) | Type::Map(_, _) => Kind::PointerPair,
Type::Enum(n) if *n <= (1 << 8) => Kind::Primitive("i32.store8"),
Type::Enum(n) if *n <= (1 << 16) => Kind::Primitive("i32.store16"),
Type::Enum(_) => Kind::Primitive("i32.store"),
Type::Flags(n) if *n <= 8 => Kind::Primitive("i32.store8"),
Type::Flags(n) if *n <= 16 => Kind::Primitive("i32.store16"),
Type::Flags(n) if *n <= 32 => Kind::Primitive("i32.store"),
Type::Flags(_) => unreachable!(),
Type::Record(_)
| Type::Tuple(_)
| Type::Variant(_)
| Type::Option(_)
| Type::Result { .. } => Kind::Helper,
};
match kind {
Kind::Primitive(op) => uwriteln!(
s,
"({op} offset={offset} (local.get {ptr}) {})",
locals.next().unwrap()
),
Kind::PointerPair => {
let abi_ptr = locals.next().unwrap();
let abi_len = locals.next().unwrap();
uwriteln!(s, "(i32.store offset={offset} (local.get {ptr}) {abi_ptr})",);
let offset = offset + 4;
uwriteln!(s, "(i32.store offset={offset} (local.get {ptr}) {abi_len})",);
}
Kind::Helper => {
let (index, _) = helpers.insert_full(Helper(self));
uwriteln!(s, "(i32.add (local.get {ptr}) (i32.const {offset}))");
for _ in 0..self.lowered().len() {
let i = locals.next().unwrap();
uwriteln!(s, "{i}");
}
uwriteln!(s, "call $store_helper_{index}");
}
}
}
/// Generates a text-format wasm function which takes a pointer and this
/// type's flat representation as arguments and then stores this value in
/// the first argument.
///
/// This is used to store records/variants to cut down on the size of final
/// functions and make codegen here a bit easier.
fn store_flat_helper<'a>(
&'a self,
s: &mut String,
i: usize,
helpers: &mut IndexSet<Helper<'a>>,
) {
uwrite!(s, "(func $store_helper_{i} (param i32)");
let lowered = self.lowered();
for ty in &lowered {
uwrite!(s, " (param {ty})");
}
s.push_str("\n");
let locals = (0..lowered.len() as u32).map(|i| i + 1).collect::<Vec<_>>();
let record = |s: &mut String, helpers: &mut IndexSet<Helper<'a>>, types: &'a [Type]| {
let mut locals = locals.iter().cloned().map(FlatSource::Local);
for (offset, ty) in record_field_offsets(types) {
ty.store_flat(s, "0", offset, &mut locals, helpers);
}
assert!(locals.next().is_none());
};
let variant = |s: &mut String,
helpers: &mut IndexSet<Helper<'a>>,
types: &[Option<&'a Type>]| {
let (size, offset) = variant_memory_info(types.iter().cloned());
// One extra block for out-of-bounds discriminants.
for _ in 0..types.len() + 1 {
s.push_str("block\n");
}
// Store the discriminant in memory, then branch on it to figure
// out which case we're in.
let store = match size {
DiscriminantSize::Size1 => "i32.store8",
DiscriminantSize::Size2 => "i32.store16",
DiscriminantSize::Size4 => "i32.store",
};
uwriteln!(s, "({store} (local.get 0) (local.get 1))");
s.push_str("local.get 1\n");
s.push_str("br_table");
for i in 0..types.len() + 1 {
uwrite!(s, " {i}");
}
s.push_str("\nend\n");
// Store each payload individually while converting locals from
// their source types to the precise type necessary for this
// variant.
for ty in types {
if let Some(ty) = ty {
let ty_lowered = ty.lowered();
let mut locals = locals[1..].iter().zip(&lowered[1..]).zip(&ty_lowered).map(
|((i, from), to)| FlatSource::LocalConvert {
local: *i,
from: *from,
to: *to,
},
);
ty.store_flat(s, "0", offset, &mut locals, helpers);
}
s.push_str("return\n");
s.push_str("end\n");
}
// Catch-all result which is for out-of-bounds discriminants.
s.push_str("unreachable\n");
};
match self {
Type::Bool
| Type::S8
| Type::U8
| Type::S16
| Type::U16
| Type::S32
| Type::U32
| Type::Char
| Type::S64
| Type::U64
| Type::Float32
| Type::Float64
| Type::String
| Type::List(_)
| Type::Map(_, _)
| Type::Flags(_)
| Type::Enum(_) => unreachable!(),
Type::Record(r) => record(s, helpers, r),
Type::Tuple(t) => record(s, helpers, t),
Type::Variant(v) => variant(
s,
helpers,
&v.iter().map(|t| t.as_ref()).collect::<Vec<_>>(),
),
Type::Option(o) => variant(s, helpers, &[None, Some(&**o)]),
Type::Result { ok, err } => variant(s, helpers, &[ok.as_deref(), err.as_deref()]),
};
s.push_str(")\n");
}
/// Same as `store_flat`, except loads the flat values from `ptr+offset`.
///
/// Results are placed directly on the wasm stack.
fn load_flat<'a>(
&'a self,
s: &mut String,
ptr: &str,
offset: u32,
helpers: &mut IndexSet<Helper<'a>>,
) {
enum Kind {
Primitive(&'static str),
PointerPair,
Helper,
}
let kind = match self {
Type::Bool | Type::U8 => Kind::Primitive("i32.load8_u"),
Type::S8 => Kind::Primitive("i32.load8_s"),
Type::U16 => Kind::Primitive("i32.load16_u"),
Type::S16 => Kind::Primitive("i32.load16_s"),
Type::U32 | Type::S32 | Type::Char => Kind::Primitive("i32.load"),
Type::U64 | Type::S64 => Kind::Primitive("i64.load"),
Type::Float32 => Kind::Primitive("f32.load"),
Type::Float64 => Kind::Primitive("f64.load"),
Type::String | Type::List(_) | Type::Map(_, _) => Kind::PointerPair,
Type::Enum(n) if *n <= (1 << 8) => Kind::Primitive("i32.load8_u"),
Type::Enum(n) if *n <= (1 << 16) => Kind::Primitive("i32.load16_u"),
Type::Enum(_) => Kind::Primitive("i32.load"),
Type::Flags(n) if *n <= 8 => Kind::Primitive("i32.load8_u"),
Type::Flags(n) if *n <= 16 => Kind::Primitive("i32.load16_u"),
Type::Flags(n) if *n <= 32 => Kind::Primitive("i32.load"),
Type::Flags(_) => unreachable!(),
Type::Record(_)
| Type::Tuple(_)
| Type::Variant(_)
| Type::Option(_)
| Type::Result { .. } => Kind::Helper,
};
match kind {
Kind::Primitive(op) => uwriteln!(s, "({op} offset={offset} (local.get {ptr}))"),
Kind::PointerPair => {
uwriteln!(s, "(i32.load offset={offset} (local.get {ptr}))",);
let offset = offset + 4;
uwriteln!(s, "(i32.load offset={offset} (local.get {ptr}))",);
}
Kind::Helper => {
let (index, _) = helpers.insert_full(Helper(self));
uwriteln!(s, "(i32.add (local.get {ptr}) (i32.const {offset}))");
uwriteln!(s, "call $load_helper_{index}");
}
}
}
/// Same as `store_flat_helper` but for loading the flat representation.
fn load_flat_helper<'a>(
&'a self,
s: &mut String,
i: usize,
helpers: &mut IndexSet<Helper<'a>>,
) {
uwrite!(s, "(func $load_helper_{i} (param i32)");
let lowered = self.lowered();
for ty in &lowered {
uwrite!(s, " (result {ty})");
}
s.push_str("\n");
let record = |s: &mut String, helpers: &mut IndexSet<Helper<'a>>, types: &'a [Type]| {
for (offset, ty) in record_field_offsets(types) {
ty.load_flat(s, "0", offset, helpers);
}
};
let variant = |s: &mut String,
helpers: &mut IndexSet<Helper<'a>>,
types: &[Option<&'a Type>]| {
let (size, offset) = variant_memory_info(types.iter().cloned());
// Destination locals where the flat representation will be stored.
// These are automatically zero which handles unused fields too.
for (i, ty) in lowered.iter().enumerate() {
uwriteln!(s, " (local $r{i} {ty})");
}
// Return block each case jumps to after setting all locals.
s.push_str("block $r\n");
// One extra block for "out of bounds discriminant".
for _ in 0..types.len() + 1 {
s.push_str("block\n");
}
// Load the discriminant and branch on it, storing it in
// `$r0` as well which is the first flat local representation.
let load = match size {
DiscriminantSize::Size1 => "i32.load8_u",
DiscriminantSize::Size2 => "i32.load16",
DiscriminantSize::Size4 => "i32.load",
};
uwriteln!(s, "({load} (local.get 0))");
s.push_str("local.tee $r0\n");
s.push_str("br_table");
for i in 0..types.len() + 1 {
uwrite!(s, " {i}");
}
s.push_str("\nend\n");
// For each payload, which is in its own block, load payloads from
// memory as necessary and convert them into the final locals.
for ty in types {
if let Some(ty) = ty {
let ty_lowered = ty.lowered();
ty.load_flat(s, "0", offset, helpers);
for (i, (from, to)) in ty_lowered.iter().zip(&lowered[1..]).enumerate().rev() {
let i = i + 1;
match (from, to) {
(CoreType::F32, CoreType::I32) => {
s.push_str("i32.reinterpret_f32\n");
}
(CoreType::I32, CoreType::I64) => {
s.push_str("i64.extend_i32_u\n");
}
(CoreType::F32, CoreType::I64) => {
s.push_str("i32.reinterpret_f32\n");
s.push_str("i64.extend_i32_u\n");
}
(CoreType::F64, CoreType::I64) => {
s.push_str("i64.reinterpret_f64\n");
}
(a, b) if a == b => {}
_ => unimplemented!("convert {from:?} to {to:?}"),
}
uwriteln!(s, "local.set $r{i}");
}
}
s.push_str("br $r\n");
s.push_str("end\n");
}
// The catch-all block for out-of-bounds discriminants.
s.push_str("unreachable\n");
s.push_str("end\n");
for i in 0..lowered.len() {
uwriteln!(s, " local.get $r{i}");
}
};
match self {
Type::Bool
| Type::S8
| Type::U8
| Type::S16
| Type::U16
| Type::S32
| Type::U32
| Type::Char
| Type::S64
| Type::U64
| Type::Float32
| Type::Float64
| Type::String
| Type::List(_)
| Type::Map(_, _)
| Type::Flags(_)
| Type::Enum(_) => unreachable!(),
Type::Record(r) => record(s, helpers, r),
Type::Tuple(t) => record(s, helpers, t),
Type::Variant(v) => variant(
s,
helpers,
&v.iter().map(|t| t.as_ref()).collect::<Vec<_>>(),
),
Type::Option(o) => variant(s, helpers, &[None, Some(&**o)]),
Type::Result { ok, err } => variant(s, helpers, &[ok.as_deref(), err.as_deref()]),
};
s.push_str(")\n");
}
}
#[derive(Clone)]
enum FlatSource {
Local(u32),
LocalConvert {
local: u32,
from: CoreType,
to: CoreType,
},
}
impl fmt::Display for FlatSource {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
FlatSource::Local(i) => write!(f, "(local.get {i})"),
FlatSource::LocalConvert { local, from, to } => {
match (from, to) {
(a, b) if a == b => write!(f, "(local.get {local})"),
(CoreType::I32, CoreType::F32) => {
write!(f, "(f32.reinterpret_i32 (local.get {local}))")
}
(CoreType::I64, CoreType::I32) => {
write!(f, "(i32.wrap_i64 (local.get {local}))")
}
(CoreType::I64, CoreType::F64) => {
write!(f, "(f64.reinterpret_i64 (local.get {local}))")
}
(CoreType::I64, CoreType::F32) => {
write!(
f,
"(f32.reinterpret_i32 (i32.wrap_i64 (local.get {local})))"
)
}
_ => unimplemented!("convert {from:?} to {to:?}"),
}
// ..
}
}
}
}
fn lower_record<'a>(types: impl Iterator<Item = &'a Type>, vec: &mut Vec<CoreType>) {
for ty in types {
ty.lower(vec);
}
}
fn lower_variant<'a>(types: impl Iterator<Item = Option<&'a Type>>, vec: &mut Vec<CoreType>) {
vec.push(CoreType::I32);
let offset = vec.len();
for ty in types {
let ty = match ty {
Some(ty) => ty,
None => continue,
};
for (index, ty) in ty.lowered().iter().enumerate() {
let index = offset + index;
if index < vec.len() {
vec[index] = vec[index].join(*ty);
} else {
vec.push(*ty)
}
}
}
}
fn u32_count_from_flag_count(count: usize) -> usize {
match FlagsSize::from_count(count) {
FlagsSize::Size0 => 0,
FlagsSize::Size1 | FlagsSize::Size2 => 1,
FlagsSize::Size4Plus(n) => n.into(),
}
}
struct SizeAndAlignment {
size: usize,
alignment: u32,
}
impl Type {
fn lowered(&self) -> Vec<CoreType> {
let mut vec = Vec::new();
self.lower(&mut vec);
vec
}
fn lower(&self, vec: &mut Vec<CoreType>) {
match self {
Type::Bool
| Type::U8
| Type::S8
| Type::S16
| Type::U16
| Type::S32
| Type::U32
| Type::Char
| Type::Enum(_) => vec.push(CoreType::I32),
Type::S64 | Type::U64 => vec.push(CoreType::I64),
Type::Float32 => vec.push(CoreType::F32),
Type::Float64 => vec.push(CoreType::F64),
Type::String | Type::List(_) | Type::Map(_, _) => {
vec.push(CoreType::I32);
vec.push(CoreType::I32);
}
Type::Record(types) => lower_record(types.iter(), vec),
Type::Tuple(types) => lower_record(types.0.iter(), vec),
Type::Variant(types) => lower_variant(types.0.iter().map(|t| t.as_ref()), vec),
Type::Option(ty) => lower_variant([None, Some(&**ty)].into_iter(), vec),
Type::Result { ok, err } => {
lower_variant([ok.as_deref(), err.as_deref()].into_iter(), vec)
}
Type::Flags(count) => vec.extend(
iter::repeat(CoreType::I32).take(u32_count_from_flag_count(*count as usize)),
),
}
}
fn size_and_alignment(&self) -> SizeAndAlignment {
match self {
Type::Bool | Type::S8 | Type::U8 => SizeAndAlignment {
size: 1,
alignment: 1,
},
Type::S16 | Type::U16 => SizeAndAlignment {
size: 2,
alignment: 2,
},
Type::S32 | Type::U32 | Type::Char | Type::Float32 => SizeAndAlignment {
size: 4,
alignment: 4,
},
Type::S64 | Type::U64 | Type::Float64 => SizeAndAlignment {
size: 8,
alignment: 8,
},
Type::String | Type::List(_) | Type::Map(_, _) => SizeAndAlignment {
size: 8,
alignment: 4,
},
Type::Record(types) => record_size_and_alignment(types.iter()),
Type::Tuple(types) => record_size_and_alignment(types.0.iter()),
Type::Variant(types) => variant_size_and_alignment(types.0.iter().map(|t| t.as_ref())),
Type::Enum(count) => variant_size_and_alignment((0..*count).map(|_| None)),
Type::Option(ty) => variant_size_and_alignment([None, Some(&**ty)].into_iter()),
Type::Result { ok, err } => {
variant_size_and_alignment([ok.as_deref(), err.as_deref()].into_iter())
}
Type::Flags(count) => match FlagsSize::from_count(*count as usize) {
FlagsSize::Size0 => SizeAndAlignment {
size: 0,
alignment: 1,
},
FlagsSize::Size1 => SizeAndAlignment {
size: 1,
alignment: 1,
},
FlagsSize::Size2 => SizeAndAlignment {
size: 2,
alignment: 2,
},
FlagsSize::Size4Plus(n) => SizeAndAlignment {
size: usize::from(n) * 4,
alignment: 4,
},
},
}
}
}
fn align_to(a: usize, align: u32) -> usize {
let align = align as usize;
(a + (align - 1)) & !(align - 1)
}
fn record_field_offsets<'a>(
types: impl IntoIterator<Item = &'a Type>,
) -> impl Iterator<Item = (u32, &'a Type)> {
let mut offset = 0;
types.into_iter().map(move |ty| {
let SizeAndAlignment { size, alignment } = ty.size_and_alignment();
let ret = align_to(offset, alignment);
offset = ret + size;
(ret as u32, ty)
})
}
fn record_size_and_alignment<'a>(types: impl IntoIterator<Item = &'a Type>) -> SizeAndAlignment {
let mut offset = 0;
let mut align = 1;
for ty in types {
let SizeAndAlignment { size, alignment } = ty.size_and_alignment();
offset = align_to(offset, alignment) + size;
align = align.max(alignment);
}
SizeAndAlignment {
size: align_to(offset, align),
alignment: align,
}
}
fn variant_size_and_alignment<'a>(
types: impl ExactSizeIterator<Item = Option<&'a Type>>,
) -> SizeAndAlignment {
let discriminant_size = DiscriminantSize::from_count(types.len()).unwrap();
let mut alignment = u32::from(discriminant_size);
let mut size = 0;
for ty in types {
if let Some(ty) = ty {
let size_and_alignment = ty.size_and_alignment();
alignment = alignment.max(size_and_alignment.alignment);
size = size.max(size_and_alignment.size);
}
}
SizeAndAlignment {
size: align_to(
align_to(usize::from(discriminant_size), alignment) + size,
alignment,
),
alignment,
}
}
fn variant_memory_info<'a>(
types: impl ExactSizeIterator<Item = Option<&'a Type>>,
) -> (DiscriminantSize, u32) {
let discriminant_size = DiscriminantSize::from_count(types.len()).unwrap();
let mut alignment = u32::from(discriminant_size);
for ty in types {
if let Some(ty) = ty {
let size_and_alignment = ty.size_and_alignment();
alignment = alignment.max(size_and_alignment.alignment);
}
}
(
discriminant_size,
align_to(usize::from(discriminant_size), alignment) as u32,
)
}
/// Generates the internals of a core wasm module which imports a single
/// component function `IMPORT_FUNCTION` and exports a single component
/// function `EXPORT_FUNCTION`.
///
/// The component function takes `params` as arguments and optionally returns
/// `result`. The `lift_abi` and `lower_abi` fields indicate the ABI in-use for
/// this operation.
fn make_import_and_export(
params: &[&Type],
result: Option<&Type>,
lift_abi: LiftAbi,
lower_abi: LowerAbi,
) -> String {
let params_lowered = params
.iter()
.flat_map(|ty| ty.lowered())
.collect::<Box<[_]>>();
let result_lowered = result.map(|t| t.lowered()).unwrap_or(Vec::new());
let mut wat = String::new();
enum Location {
Flat,
Indirect(u32),
}
// Generate the core wasm type corresponding to the imported function being
// lowered with `lower_abi`.
wat.push_str(&format!("(type $import (func"));
let max_import_params = match lower_abi {
LowerAbi::Sync => MAX_FLAT_PARAMS,
LowerAbi::Async => MAX_FLAT_ASYNC_PARAMS,
};
let (import_params_loc, nparams) = push_params(&mut wat, ¶ms_lowered, max_import_params);
let import_results_loc = match lower_abi {
LowerAbi::Sync => {
push_result_or_retptr(&mut wat, &result_lowered, nparams, MAX_FLAT_RESULTS)
}
LowerAbi::Async => {
let loc = if result.is_none() {
Location::Flat
} else {
wat.push_str(" (param i32)"); // result pointer
Location::Indirect(nparams)
};
wat.push_str(" (result i32)"); // status code
loc
}
};
wat.push_str("))\n");
// Generate the import function.
wat.push_str(&format!(
r#"(import "host" "{IMPORT_FUNCTION}" (func $host (type $import)))"#
));
// Do the same as above for the exported function's type which is lifted
// with `lift_abi`.
//
// Note that `export_results_loc` being `None` means that `task.return` is
// used to communicate results.
wat.push_str(&format!("(type $export (func"));
let (export_params_loc, _nparams) = push_params(&mut wat, ¶ms_lowered, MAX_FLAT_PARAMS);
let export_results_loc = match lift_abi {
LiftAbi::Sync => Some(push_group(&mut wat, "result", &result_lowered, MAX_FLAT_RESULTS).0),
LiftAbi::AsyncCallback => {
wat.push_str(" (result i32)"); // status code
None
}
LiftAbi::AsyncStackful => None,
};
wat.push_str("))\n");
// If the export is async, generate `task.return` as an import as well
// which is necessary to communicate the results.
if export_results_loc.is_none() {
wat.push_str(&format!("(type $task.return (func"));
push_params(&mut wat, &result_lowered, MAX_FLAT_PARAMS);
wat.push_str("))\n");
wat.push_str(&format!(
r#"(import "" "task.return" (func $task.return (type $task.return)))"#
));
}
wat.push_str(&format!(
r#"
(func (export "{EXPORT_FUNCTION}") (type $export)
(local $retptr i32)
(local $argptr i32)
"#
));
let mut store_helpers = IndexSet::new();
let mut load_helpers = IndexSet::new();
match (export_params_loc, import_params_loc) {
// flat => flat is just moving locals around
(Location::Flat, Location::Flat) => {
for (index, _) in params_lowered.iter().enumerate() {
uwrite!(wat, "local.get {index}\n");
}
}
// indirect => indirect is just moving locals around
(Location::Indirect(i), Location::Indirect(j)) => {
assert_eq!(j, 0);
uwrite!(wat, "local.get {i}\n");
}
// flat => indirect means that all parameters are stored in memory as
// if it was a record of all the parameters.
(Location::Flat, Location::Indirect(_)) => {
let SizeAndAlignment { size, alignment } =
record_size_and_alignment(params.iter().cloned());
wat.push_str(&format!(
r#"
(local.set $argptr
(call $realloc
(i32.const 0)
(i32.const 0)
(i32.const {alignment})
(i32.const {size})))
local.get $argptr
"#
));
let mut locals = (0..params_lowered.len() as u32).map(FlatSource::Local);
for (offset, ty) in record_field_offsets(params.iter().cloned()) {
ty.store_flat(&mut wat, "$argptr", offset, &mut locals, &mut store_helpers);
}
assert!(locals.next().is_none());
}
(Location::Indirect(_), Location::Flat) => unreachable!(),
}
// Pass a return-pointer if necessary.
match import_results_loc {
Location::Flat => {}
Location::Indirect(_) => {
let SizeAndAlignment { size, alignment } = result.unwrap().size_and_alignment();
wat.push_str(&format!(
r#"
(local.set $retptr
(call $realloc
(i32.const 0)
(i32.const 0)
(i32.const {alignment})
(i32.const {size})))
local.get $retptr
"#
));
}
}
wat.push_str("call $host\n");
// Assert the lowered call is ready if an async code was returned.
//
// TODO: handle when the import isn't ready yet
if let LowerAbi::Async = lower_abi {
wat.push_str("i32.const 2\n");
wat.push_str("i32.ne\n");
wat.push_str("if unreachable end\n");
}
// TODO: conditionally inject a yield here
match (import_results_loc, export_results_loc) {
// flat => flat results involves nothing, the results are already on
// the stack.
(Location::Flat, Some(Location::Flat)) => {}
// indirect => indirect results requires returning the `$retptr` the
// host call filled in.
(Location::Indirect(_), Some(Location::Indirect(_))) => {
wat.push_str("local.get $retptr\n");
}
// indirect => flat requires loading the result from the return pointer
(Location::Indirect(_), Some(Location::Flat)) => {
result
.unwrap()
.load_flat(&mut wat, "$retptr", 0, &mut load_helpers);
}
// flat => task.return is easy, the results are already there so just
// call the function.
(Location::Flat, None) => {
wat.push_str("call $task.return\n");
}
// indirect => task.return needs to forward `$retptr` if the results
// are indirect, or otherwise it must be loaded from memory to a flat
// representation.
(Location::Indirect(_), None) => {
if result_lowered.len() <= MAX_FLAT_PARAMS {
result
.unwrap()
.load_flat(&mut wat, "$retptr", 0, &mut load_helpers);
} else {
wat.push_str("local.get $retptr\n");
}
wat.push_str("call $task.return\n");
}
(Location::Flat, Some(Location::Indirect(_))) => unreachable!(),
}
if let LiftAbi::AsyncCallback = lift_abi {
wat.push_str("i32.const 0\n"); // completed status code
}
wat.push_str(")\n");
// Generate a `callback` function for the callback ABI.
//
// TODO: fill this in
if let LiftAbi::AsyncCallback = lift_abi {
wat.push_str(
r#"
(func (export "callback") (param i32 i32 i32) (result i32) unreachable)
"#,
);
}
// Fill out all store/load helpers that were needed during generation
// above. This is a fix-point-loop since each helper may end up requiring
// more helpers.
let mut i = 0;
while i < store_helpers.len() {
let ty = store_helpers[i].0;
ty.store_flat_helper(&mut wat, i, &mut store_helpers);
i += 1;
}
i = 0;
while i < load_helpers.len() {
let ty = load_helpers[i].0;
ty.load_flat_helper(&mut wat, i, &mut load_helpers);
i += 1;
}
return wat;
fn push_params(wat: &mut String, params: &[CoreType], max_flat: usize) -> (Location, u32) {
push_group(wat, "param", params, max_flat)
}
fn push_group(
wat: &mut String,
name: &str,
params: &[CoreType],
max_flat: usize,
) -> (Location, u32) {
let mut nparams = 0;
let loc = if params.is_empty() {
// nothing to emit...
Location::Flat
} else if params.len() <= max_flat {
wat.push_str(&format!(" ({name}"));
for ty in params {
wat.push_str(&format!(" {ty}"));
nparams += 1;
}
wat.push_str(")");
Location::Flat
} else {
wat.push_str(&format!(" ({name} i32)"));
nparams += 1;
Location::Indirect(0)
};
(loc, nparams)
}
fn push_result_or_retptr(
wat: &mut String,
results: &[CoreType],
nparams: u32,
max_flat: usize,
) -> Location {
if results.is_empty() {
// nothing to emit...
Location::Flat
} else if results.len() <= max_flat {
wat.push_str(" (result");
for ty in results {
wat.push_str(&format!(" {ty}"));
}
wat.push_str(")");
Location::Flat
} else {
wat.push_str(" (param i32)");
Location::Indirect(nparams)
}
}
}
struct Helper<'a>(&'a Type);
impl Hash for Helper<'_> {
fn hash<H: Hasher>(&self, h: &mut H) {
std::ptr::hash(self.0, h);
}
}
impl PartialEq for Helper<'_> {
fn eq(&self, other: &Self) -> bool {
std::ptr::eq(self.0, other.0)
}
}
impl Eq for Helper<'_> {}
fn make_rust_name(name_counter: &mut u32) -> Ident {
let name = format_ident!("Foo{name_counter}");
*name_counter += 1;
name
}
/// Generate a [`TokenStream`] containing the rust type name for a type.
///
/// The `name_counter` parameter is used to generate names for each recursively visited type. The `declarations`
/// parameter is used to accumulate declarations for each recursively visited type.
pub fn rust_type(ty: &Type, name_counter: &mut u32, declarations: &mut TokenStream) -> TokenStream {
match ty {
Type::Bool => quote!(bool),
Type::S8 => quote!(i8),
Type::U8 => quote!(u8),
Type::S16 => quote!(i16),
Type::U16 => quote!(u16),
Type::S32 => quote!(i32),
Type::U32 => quote!(u32),
Type::S64 => quote!(i64),
Type::U64 => quote!(u64),
Type::Float32 => quote!(Float32),
Type::Float64 => quote!(Float64),
Type::Char => quote!(char),
Type::String => quote!(Box<str>),
Type::List(ty) => {
let ty = rust_type(ty, name_counter, declarations);
quote!(Vec<#ty>)
}
Type::Map(key_ty, value_ty) => {
let key_ty = rust_type(key_ty, name_counter, declarations);
let value_ty = rust_type(value_ty, name_counter, declarations);
quote!(std::collections::HashMap<#key_ty, #value_ty>)
}
Type::Record(types) => {
let fields = types
.iter()
.enumerate()
.map(|(index, ty)| {
let name = format_ident!("f{index}");
let ty = rust_type(ty, name_counter, declarations);
quote!(#name: #ty,)
})
.collect::<TokenStream>();
let name = make_rust_name(name_counter);
declarations.extend(quote! {
#[derive(ComponentType, Lift, Lower, PartialEq, Debug, Clone, Arbitrary)]
#[component(record)]
struct #name {
#fields
}
});
quote!(#name)
}
Type::Tuple(types) => {
let fields = types
.0
.iter()
.map(|ty| {
let ty = rust_type(ty, name_counter, declarations);
quote!(#ty,)
})
.collect::<TokenStream>();
quote!((#fields))
}
Type::Variant(types) => {
let cases = types
.0
.iter()
.enumerate()
.map(|(index, ty)| {
let name = format_ident!("C{index}");
let ty = match ty {
Some(ty) => {
let ty = rust_type(ty, name_counter, declarations);
quote!((#ty))
}
None => quote!(),
};
quote!(#name #ty,)
})
.collect::<TokenStream>();
let name = make_rust_name(name_counter);
declarations.extend(quote! {
#[derive(ComponentType, Lift, Lower, PartialEq, Debug, Clone, Arbitrary)]
#[component(variant)]
enum #name {
#cases
}
});
quote!(#name)
}
Type::Enum(count) => {
let cases = (0..*count)
.map(|index| {
let name = format_ident!("E{index}");
quote!(#name,)
})
.collect::<TokenStream>();
let name = make_rust_name(name_counter);
let repr = match DiscriminantSize::from_count(*count as usize).unwrap() {
DiscriminantSize::Size1 => quote!(u8),
DiscriminantSize::Size2 => quote!(u16),
DiscriminantSize::Size4 => quote!(u32),
};
declarations.extend(quote! {
#[derive(ComponentType, Lift, Lower, PartialEq, Eq, Hash, Debug, Copy, Clone, Arbitrary)]
#[component(enum)]
#[repr(#repr)]
enum #name {
#cases
}
});
quote!(#name)
}
Type::Option(ty) => {
let ty = rust_type(ty, name_counter, declarations);
quote!(Option<#ty>)
}
Type::Result { ok, err } => {
let ok = match ok {
Some(ok) => rust_type(ok, name_counter, declarations),
None => quote!(()),
};
let err = match err {
Some(err) => rust_type(err, name_counter, declarations),
None => quote!(()),
};
quote!(Result<#ok, #err>)
}
Type::Flags(count) => {
let type_name = make_rust_name(name_counter);
let mut flags = TokenStream::new();
let mut names = TokenStream::new();
for index in 0..*count {
let name = format_ident!("F{index}");
flags.extend(quote!(const #name;));
names.extend(quote!(#type_name::#name,))
}
declarations.extend(quote! {
wasmtime::component::flags! {
#type_name {
#flags
}
}
impl<'a> arbitrary::Arbitrary<'a> for #type_name {
fn arbitrary(input: &mut arbitrary::Unstructured<'a>) -> arbitrary::Result<Self> {
let mut flags = #type_name::default();
for flag in [#names] {
if input.arbitrary()? {
flags |= flag;
}
}
Ok(flags)
}
}
});
quote!(#type_name)
}
}
}
#[derive(Default)]
struct TypesBuilder<'a> {
next: u32,
worklist: Vec<(u32, &'a Type)>,
}
impl<'a> TypesBuilder<'a> {
fn write_ref(&mut self, ty: &'a Type, dst: &mut String) {
match ty {
// Primitive types can be referenced directly
Type::Bool => dst.push_str("bool"),
Type::S8 => dst.push_str("s8"),
Type::U8 => dst.push_str("u8"),
Type::S16 => dst.push_str("s16"),
Type::U16 => dst.push_str("u16"),
Type::S32 => dst.push_str("s32"),
Type::U32 => dst.push_str("u32"),
Type::S64 => dst.push_str("s64"),
Type::U64 => dst.push_str("u64"),
Type::Float32 => dst.push_str("float32"),
Type::Float64 => dst.push_str("float64"),
Type::Char => dst.push_str("char"),
Type::String => dst.push_str("string"),
// Otherwise emit a reference to the type and remember to generate
// the corresponding type alias later.
Type::List(_)
| Type::Map(_, _)
| Type::Record(_)
| Type::Tuple(_)
| Type::Variant(_)
| Type::Enum(_)
| Type::Option(_)
| Type::Result { .. }
| Type::Flags(_) => {
let idx = self.next;
self.next += 1;
uwrite!(dst, "$t{idx}");
self.worklist.push((idx, ty));
}
}
}
fn write_decl(&mut self, idx: u32, ty: &'a Type) -> String {
let mut decl = format!("(type $t{idx}' ");
match ty {
Type::Bool
| Type::S8
| Type::U8
| Type::S16
| Type::U16
| Type::S32
| Type::U32
| Type::S64
| Type::U64
| Type::Float32
| Type::Float64
| Type::Char
| Type::String => unreachable!(),
Type::List(ty) => {
decl.push_str("(list ");
self.write_ref(ty, &mut decl);
decl.push_str(")");
}
Type::Map(key_ty, value_ty) => {
decl.push_str("(map ");
self.write_ref(key_ty, &mut decl);
decl.push_str(" ");
self.write_ref(value_ty, &mut decl);
decl.push_str(")");
}
Type::Record(types) => {
decl.push_str("(record");
for (index, ty) in types.iter().enumerate() {
uwrite!(decl, r#" (field "f{index}" "#);
self.write_ref(ty, &mut decl);
decl.push_str(")");
}
decl.push_str(")");
}
Type::Tuple(types) => {
decl.push_str("(tuple");
for ty in types.iter() {
decl.push_str(" ");
self.write_ref(ty, &mut decl);
}
decl.push_str(")");
}
Type::Variant(types) => {
decl.push_str("(variant");
for (index, ty) in types.iter().enumerate() {
uwrite!(decl, r#" (case "C{index}""#);
if let Some(ty) = ty {
decl.push_str(" ");
self.write_ref(ty, &mut decl);
}
decl.push_str(")");
}
decl.push_str(")");
}
Type::Enum(count) => {
decl.push_str("(enum");
for index in 0..*count {
uwrite!(decl, r#" "E{index}""#);
}
decl.push_str(")");
}
Type::Option(ty) => {
decl.push_str("(option ");
self.write_ref(ty, &mut decl);
decl.push_str(")");
}
Type::Result { ok, err } => {
decl.push_str("(result");
if let Some(ok) = ok {
decl.push_str(" ");
self.write_ref(ok, &mut decl);
}
if let Some(err) = err {
decl.push_str(" (error ");
self.write_ref(err, &mut decl);
decl.push_str(")");
}
decl.push_str(")");
}
Type::Flags(count) => {
decl.push_str("(flags");
for index in 0..*count {
uwrite!(decl, r#" "F{index}""#);
}
decl.push_str(")");
}
}
decl.push_str(")\n");
uwriteln!(decl, "(import \"t{idx}\" (type $t{idx} (eq $t{idx}')))");
decl
}
}
/// Represents custom fragments of a WAT file which may be used to create a component for exercising [`TestCase`]s
#[derive(Debug)]
pub struct Declarations {
/// Type declarations (if any) referenced by `params` and/or `result`
pub types: Cow<'static, str>,
/// Types to thread through when instantiating sub-components.
pub type_instantiation_args: Cow<'static, str>,
/// Parameter declarations used for the imported and exported functions
pub params: Cow<'static, str>,
/// Result declaration used for the imported and exported functions
pub results: Cow<'static, str>,
/// Implementation of the "caller" component, which invokes the `callee`
/// composed component.
pub caller_module: Cow<'static, str>,
/// Implementation of the "callee" component, which invokes the host.
pub callee_module: Cow<'static, str>,
/// Options used for caller/calle ABI/etc.
pub options: TestCaseOptions,
}
impl Declarations {
/// Generate a complete WAT file based on the specified fragments.
pub fn make_component(&self) -> Box<str> {
let Self {
types,
type_instantiation_args,
params,
results,
caller_module,
callee_module,
options,
} = self;
let mk_component = |name: &str,
module: &str,
import_async: bool,
export_async: bool,
encoding: StringEncoding,
lift_abi: LiftAbi,
lower_abi: LowerAbi| {
let import_async = if import_async { "async" } else { "" };
let export_async = if export_async { "async" } else { "" };
let lower_async_option = match lower_abi {
LowerAbi::Sync => "",
LowerAbi::Async => "async",
};
let lift_async_option = match lift_abi {
LiftAbi::Sync => "",
LiftAbi::AsyncStackful => "async",
LiftAbi::AsyncCallback => "async (callback (core func $i \"callback\"))",
};
let mut intrinsic_defs = String::new();
let mut intrinsic_imports = String::new();
match lift_abi {
LiftAbi::Sync => {}
LiftAbi::AsyncCallback | LiftAbi::AsyncStackful => {
intrinsic_defs.push_str(&format!(
r#"
(core func $task.return (canon task.return {results}
(memory (core memory $libc "memory")) string-encoding={encoding}))
"#,
));
intrinsic_imports.push_str(
r#"
(with "" (instance (export "task.return" (func $task.return))))
"#,
);
}
}
format!(
r#"
(component ${name}
{types}
(type $import_sig (func {import_async} {params} {results}))
(type $export_sig (func {export_async} {params} {results}))
(import "{IMPORT_FUNCTION}" (func $f (type $import_sig)))
(core instance $libc (instantiate $libc))
(core func $f_lower (canon lower
(func $f)
(memory (core memory $libc "memory"))
(realloc (core func $libc "realloc"))
string-encoding={encoding}
{lower_async_option}
))
{intrinsic_defs}
(core module $m
(memory (import "libc" "memory") 1)
(func $realloc (import "libc" "realloc") (param i32 i32 i32 i32) (result i32))
{module}
)
(core instance $i (instantiate $m
(with "libc" (instance $libc))
(with "host" (instance (export "{IMPORT_FUNCTION}" (func $f_lower))))
{intrinsic_imports}
))
(func (export "{EXPORT_FUNCTION}") (type $export_sig)
(canon lift
(core func $i "{EXPORT_FUNCTION}")
(memory (core memory $libc "memory"))
(realloc (core func $libc "realloc"))
string-encoding={encoding}
{lift_async_option}
)
)
)
"#
)
};
let c1 = mk_component(
"callee",
&callee_module,
options.host_async,
options.guest_callee_async,
options.callee_encoding,
options.callee_lift_abi,
options.callee_lower_abi,
);
let c2 = mk_component(
"caller",
&caller_module,
options.guest_callee_async,
options.guest_caller_async,
options.caller_encoding,
options.caller_lift_abi,
options.caller_lower_abi,
);
let host_async = if options.host_async { "async" } else { "" };
format!(
r#"
(component
(core module $libc
(memory (export "memory") 1)
{REALLOC_AND_FREE}
)
{types}
(type $host_sig (func {host_async} {params} {results}))
(import "{IMPORT_FUNCTION}" (func $f (type $host_sig)))
{c1}
{c2}
(instance $c1 (instantiate $callee
{type_instantiation_args}
(with "{IMPORT_FUNCTION}" (func $f))
))
(instance $c2 (instantiate $caller
{type_instantiation_args}
(with "{IMPORT_FUNCTION}" (func $c1 "{EXPORT_FUNCTION}"))
))
(export "{EXPORT_FUNCTION}" (func $c2 "{EXPORT_FUNCTION}"))
)"#,
)
.into()
}
}
/// Represents a test case for calling a component function
#[derive(Debug)]
pub struct TestCase<'a> {
/// The types of parameters to pass to the function
pub params: Vec<&'a Type>,
/// The result types of the function
pub result: Option<&'a Type>,
/// ABI options to use for this test case.
pub options: TestCaseOptions,
}
/// Collection of options which configure how the caller/callee/etc ABIs are
/// all configured.
#[derive(Debug, Arbitrary, Copy, Clone)]
pub struct TestCaseOptions {
/// Whether or not the guest caller component (the entrypoint) is using an
/// `async` function type.
pub guest_caller_async: bool,
/// Whether or not the guest callee component (what the entrypoint calls)
/// is using an `async` function type.
pub guest_callee_async: bool,
/// Whether or not the host is using an async function type (what the
/// guest callee calls).
pub host_async: bool,
/// The string encoding of the caller component.
pub caller_encoding: StringEncoding,
/// The string encoding of the callee component.
pub callee_encoding: StringEncoding,
/// The ABI that the caller component is using to lift its export (the main
/// entrypoint).
pub caller_lift_abi: LiftAbi,
/// The ABI that the callee component is using to lift its export (called
/// by the caller).
pub callee_lift_abi: LiftAbi,
/// The ABI that the caller component is using to lower its import (the
/// callee's export).
pub caller_lower_abi: LowerAbi,
/// The ABI that the callee component is using to lower its import (the
/// host function).
pub callee_lower_abi: LowerAbi,
}
#[derive(Debug, Arbitrary, Copy, Clone)]
pub enum LiftAbi {
Sync,
AsyncStackful,
AsyncCallback,
}
#[derive(Debug, Arbitrary, Copy, Clone)]
pub enum LowerAbi {
Sync,
Async,
}
impl LiftAbi {
fn is_async(self) -> bool {
!matches!(self, Self::Sync)
}
fn ensure_async(&mut self) {
if !self.is_async() {
*self = Self::AsyncStackful;
}
}
}
impl LowerAbi {
fn is_async(self) -> bool {
matches!(self, Self::Async)
}
fn ensure_async(&mut self) {
*self = Self::Async;
}
}
impl<'a> TestCase<'a> {
pub fn generate(types: &'a [Type], u: &mut Unstructured<'_>) -> arbitrary::Result<Self> {
let max_params = if types.len() > 0 { 5 } else { 0 };
let params = (0..u.int_in_range(0..=max_params)?)
.map(|_| u.choose(&types))
.collect::<arbitrary::Result<Vec<_>>>()?;
let result = if types.len() > 0 && u.arbitrary()? {
Some(u.choose(&types)?)
} else {
None
};
let mut options = u.arbitrary::<TestCaseOptions>()?;
// Keep each boundary self-consistent: async function types require async
// lowering/lifting, and async callees force their callers async too.
if options.host_async || options.callee_lower_abi.is_async() {
options.host_async = true;
options.callee_lower_abi.ensure_async();
options.guest_callee_async = true;
}
if options.guest_callee_async
|| options.callee_lift_abi.is_async()
|| options.caller_lower_abi.is_async()
{
options.guest_callee_async = true;
options.callee_lift_abi.ensure_async();
options.caller_lower_abi.ensure_async();
options.guest_caller_async = true;
}
if options.guest_caller_async || options.caller_lift_abi.is_async() {
options.guest_caller_async = true;
options.caller_lift_abi.ensure_async();
}
Ok(Self {
params,
result,
options,
})
}
/// Generate a `Declarations` for this `TestCase` which may be used to build a component to execute the case.
pub fn declarations(&self) -> Declarations {
let mut builder = TypesBuilder::default();
let mut params = String::new();
for (i, ty) in self.params.iter().enumerate() {
params.push_str(&format!(" (param \"p{i}\" "));
builder.write_ref(ty, &mut params);
params.push_str(")");
}
let mut results = String::new();
if let Some(ty) = self.result {
results.push_str(&format!(" (result "));
builder.write_ref(ty, &mut results);
results.push_str(")");
}
let caller_module = make_import_and_export(
&self.params,
self.result,
self.options.caller_lift_abi,
self.options.caller_lower_abi,
);
let callee_module = make_import_and_export(
&self.params,
self.result,
self.options.callee_lift_abi,
self.options.callee_lower_abi,
);
let mut type_decls = Vec::new();
let mut type_instantiation_args = String::new();
while let Some((idx, ty)) = builder.worklist.pop() {
type_decls.push(builder.write_decl(idx, ty));
uwriteln!(type_instantiation_args, "(with \"t{idx}\" (type $t{idx}))");
}
// Note that types are printed here in reverse order since they were
// pushed onto `type_decls` as they were referenced meaning the last one
// is the "base" one.
let mut types = String::new();
for decl in type_decls.into_iter().rev() {
types.push_str(&decl);
types.push_str("\n");
}
Declarations {
types: types.into(),
type_instantiation_args: type_instantiation_args.into(),
params: params.into(),
results: results.into(),
caller_module: caller_module.into(),
callee_module: callee_module.into(),
options: self.options,
}
}
}
#[derive(Copy, Clone, Debug, Arbitrary)]
pub enum StringEncoding {
Utf8,
Utf16,
Latin1OrUtf16,
}
impl fmt::Display for StringEncoding {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
StringEncoding::Utf8 => fmt::Display::fmt(&"utf8", f),
StringEncoding::Utf16 => fmt::Display::fmt(&"utf16", f),
StringEncoding::Latin1OrUtf16 => fmt::Display::fmt(&"latin1+utf16", f),
}
}
}
impl ToTokens for TestCaseOptions {
fn to_tokens(&self, tokens: &mut TokenStream) {
let TestCaseOptions {
guest_caller_async,
guest_callee_async,
host_async,
caller_encoding,
callee_encoding,
caller_lift_abi,
callee_lift_abi,
caller_lower_abi,
callee_lower_abi,
} = self;
tokens.extend(quote!(wasmtime_test_util::component_fuzz::TestCaseOptions {
guest_caller_async: #guest_caller_async,
guest_callee_async: #guest_callee_async,
host_async: #host_async,
caller_encoding: #caller_encoding,
callee_encoding: #callee_encoding,
caller_lift_abi: #caller_lift_abi,
callee_lift_abi: #callee_lift_abi,
caller_lower_abi: #caller_lower_abi,
callee_lower_abi: #callee_lower_abi,
}));
}
}
impl ToTokens for LowerAbi {
fn to_tokens(&self, tokens: &mut TokenStream) {
let me = match self {
LowerAbi::Sync => quote!(Sync),
LowerAbi::Async => quote!(Async),
};
tokens.extend(quote!(wasmtime_test_util::component_fuzz::LowerAbi::#me));
}
}
impl ToTokens for LiftAbi {
fn to_tokens(&self, tokens: &mut TokenStream) {
let me = match self {
LiftAbi::Sync => quote!(Sync),
LiftAbi::AsyncCallback => quote!(AsyncCallback),
LiftAbi::AsyncStackful => quote!(AsyncStackful),
};
tokens.extend(quote!(wasmtime_test_util::component_fuzz::LiftAbi::#me));
}
}
impl ToTokens for StringEncoding {
fn to_tokens(&self, tokens: &mut TokenStream) {
let me = match self {
StringEncoding::Utf8 => quote!(Utf8),
StringEncoding::Utf16 => quote!(Utf16),
StringEncoding::Latin1OrUtf16 => quote!(Latin1OrUtf16),
};
tokens.extend(quote!(wasmtime_test_util::component_fuzz::StringEncoding::#me));
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn arbtest() {
arbtest::arbtest(|u| {
let mut fuel = 100;
let types = (0..5)
.map(|_| Type::generate(u, 3, &mut fuel))
.collect::<arbitrary::Result<Vec<_>>>()?;
let case = TestCase::generate(&types, u)?;
let decls = case.declarations();
let component = decls.make_component();
let wasm = wat::parse_str(&component).unwrap_or_else(|e| {
panic!("failed to parse generated component as wat: {e}\n\n{component}");
});
wasmparser::Validator::new_with_features(wasmparser::WasmFeatures::all())
.validate_all(&wasm)
.unwrap_or_else(|e| {
let mut wat = String::new();
let mut dst = wasmprinter::PrintFmtWrite(&mut wat);
let to_print = if wasmprinter::Config::new()
.print_offsets(true)
.print_operand_stack(true)
.print(&wasm, &mut dst)
.is_ok()
{
&wat[..]
} else {
&component[..]
};
panic!("generated component is not valid wasm: {e}\n\n{to_print}");
});
Ok(())
})
.budget_ms(1_000)
// .seed(0x3c9050d4000000e9)
;
}
}