A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
use wasmtime::*;
fn field(heap_ty: HeapType) -> FieldType {
FieldType::new(
Mutability::Var,
StorageType::ValType(RefType::new(true, heap_ty).into()),
)
}
fn imm_field(heap_ty: HeapType) -> FieldType {
FieldType::new(
Mutability::Const,
StorageType::ValType(RefType::new(true, heap_ty).into()),
)
}
fn valty(heap_ty: HeapType) -> ValType {
ValType::Ref(RefType::new(true, heap_ty))
}
#[test]
fn heap_type_top_and_bottom() {
for (heap_type, top, bottom) in [
(
HeapType::Extern,
HeapTopType::Extern,
HeapBottomType::NoExtern,
),
(
HeapType::NoExtern,
HeapTopType::Extern,
HeapBottomType::NoExtern,
),
(HeapType::Func, HeapTopType::Func, HeapBottomType::NoFunc),
(HeapType::NoFunc, HeapTopType::Func, HeapBottomType::NoFunc),
(HeapType::Any, HeapTopType::Any, HeapBottomType::None),
(HeapType::Eq, HeapTopType::Any, HeapBottomType::None),
(HeapType::I31, HeapTopType::Any, HeapBottomType::None),
(HeapType::Array, HeapTopType::Any, HeapBottomType::None),
(HeapType::Struct, HeapTopType::Any, HeapBottomType::None),
(HeapType::None, HeapTopType::Any, HeapBottomType::None),
(HeapType::Cont, HeapTopType::Cont, HeapBottomType::NoCont),
(HeapType::NoCont, HeapTopType::Cont, HeapBottomType::NoCont),
(HeapType::Exn, HeapTopType::Exn, HeapBottomType::NoExn),
(HeapType::NoExn, HeapTopType::Exn, HeapBottomType::NoExn),
] {
assert_eq!(heap_type.top(), top);
assert_eq!(heap_type.bottom(), bottom);
}
}
#[test]
fn basic_array_types() -> Result<()> {
let engine = Engine::default();
for mutability in [Mutability::Const, Mutability::Var] {
for storage_ty in [
StorageType::I8,
StorageType::I16,
StorageType::ValType(ValType::I32),
StorageType::ValType(RefType::new(true, FuncType::new(&engine, [], []).into()).into()),
] {
let field_ty = FieldType::new(mutability, storage_ty.clone());
assert_eq!(field_ty.mutability(), mutability);
assert!(StorageType::eq(field_ty.element_type(), &storage_ty));
let array_ty = ArrayType::new(&engine, field_ty.clone());
assert!(Engine::same(array_ty.engine(), &engine));
assert!(FieldType::eq(&array_ty.field_type(), &field_ty));
assert_eq!(array_ty.mutability(), mutability);
assert!(StorageType::eq(&array_ty.element_type(), &storage_ty));
}
}
Ok(())
}
#[test]
fn empty_struct_type() -> Result<()> {
let engine = Engine::default();
let struct_ty = StructType::new(&engine, [])?;
assert_eq!(struct_ty.fields().len(), 0);
assert!(struct_ty.field(0).is_none());
Ok(())
}
#[test]
fn basic_struct_types() -> Result<()> {
let engine = Engine::default();
let field_types = || {
[Mutability::Const, Mutability::Var]
.into_iter()
.flat_map(|mutability| {
[
StorageType::I8,
StorageType::I16,
StorageType::ValType(ValType::I32),
StorageType::ValType(
RefType::new(true, FuncType::new(&engine, [], []).into()).into(),
),
]
.into_iter()
.map(move |storage_ty| FieldType::new(mutability, storage_ty))
})
};
let struct_ty = StructType::new(&engine, field_types())?;
assert_eq!(struct_ty.fields().len(), field_types().count());
for ((i, expected), actual) in field_types().enumerate().zip(struct_ty.fields()) {
assert!(FieldType::eq(&expected, &actual));
assert!(FieldType::eq(&expected, &struct_ty.field(i).unwrap()));
}
assert!(struct_ty.field(struct_ty.fields().len()).is_none());
Ok(())
}
#[test]
fn struct_type_matches() -> Result<()> {
let engine = Engine::default();
let super_ty = StructType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
None,
[imm_field(HeapType::Func)],
)?;
// Depth.
let sub_ty = StructType::with_finality_and_supertype(
&engine,
Finality::Final,
Some(&super_ty),
[imm_field(HeapType::NoFunc)],
)?;
assert!(sub_ty.matches(&super_ty));
let not_sub_ty = StructType::new(&engine, [imm_field(HeapType::NoFunc)])?;
assert!(!not_sub_ty.matches(&super_ty));
// Width.
let sub_ty = StructType::with_finality_and_supertype(
&engine,
Finality::Final,
Some(&super_ty),
[imm_field(HeapType::Func), imm_field(HeapType::Extern)],
)?;
assert!(sub_ty.matches(&super_ty));
let not_sub_ty = StructType::new(
&engine,
[imm_field(HeapType::Func), imm_field(HeapType::Extern)],
)?;
assert!(!not_sub_ty.matches(&super_ty));
// Depth and width.
let sub_ty = StructType::with_finality_and_supertype(
&engine,
Finality::Final,
Some(&super_ty),
[imm_field(HeapType::NoFunc), imm_field(HeapType::Extern)],
)?;
assert!(sub_ty.matches(&super_ty));
let not_sub_ty = StructType::new(
&engine,
[imm_field(HeapType::NoFunc), imm_field(HeapType::Extern)],
)?;
assert!(!not_sub_ty.matches(&super_ty));
// Unrelated structs.
let not_sub_ty = StructType::new(&engine, [imm_field(HeapType::Extern)])?;
assert!(!not_sub_ty.matches(&super_ty));
let not_sub_ty = StructType::new(&engine, [field(HeapType::Extern)])?;
assert!(!not_sub_ty.matches(&super_ty));
let not_sub_ty = StructType::new(&engine, [])?;
assert!(!not_sub_ty.matches(&super_ty));
Ok(())
}
#[test]
fn struct_subtyping_fields_must_match() -> Result<()> {
let engine = Engine::default();
let a = StructType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
None,
[imm_field(HeapType::Any)],
)?;
for (msg, expected, fields) in [
("Missing field", false, vec![]),
(
"Non-matching field",
false,
vec![imm_field(HeapType::Extern)],
),
("Wrong mutability field", false, vec![field(HeapType::Any)]),
("Exact match is okay", true, vec![imm_field(HeapType::Any)]),
(
"Subtype of the field is okay",
true,
vec![imm_field(HeapType::Eq)],
),
(
"Extra fields are okay",
true,
vec![imm_field(HeapType::Any), imm_field(HeapType::Extern)],
),
] {
let actual =
StructType::with_finality_and_supertype(&engine, Finality::NonFinal, Some(&a), fields)
.is_ok();
assert_eq!(
expected, actual,
"expected valid? {expected}; actually valid? {actual}; {msg}"
);
}
Ok(())
}
#[test]
fn struct_subtyping_supertype_and_finality() -> Result<()> {
let engine = Engine::default();
for (expected, finality) in [(true, Finality::NonFinal), (false, Finality::Final)] {
let a = StructType::with_finality_and_supertype(&engine, finality, None, [])?;
let actual =
StructType::with_finality_and_supertype(&engine, Finality::Final, Some(&a), []).is_ok();
assert_eq!(expected, actual);
}
Ok(())
}
#[test]
fn struct_subtyping() -> Result<()> {
let engine = Engine::default();
// These types produce the following trees:
//
// base g
// / \ /
// a b h
// / \ /
// c d i
// /
// e
// /
// f
let base = StructType::with_finality_and_supertype(&engine, Finality::NonFinal, None, [])?;
let a = StructType::with_finality_and_supertype(&engine, Finality::NonFinal, Some(&base), [])?;
let b = StructType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
Some(&base),
// Have to add a field so that `b` doesn't dedupe to `a`.
[field(HeapType::Any)],
)?;
let c = StructType::with_finality_and_supertype(&engine, Finality::NonFinal, Some(&a), [])?;
let d = StructType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
Some(&a),
// Have to add a field so that `d` doesn't dedupe to `c`.
[field(HeapType::Any)],
)?;
let e = StructType::with_finality_and_supertype(&engine, Finality::NonFinal, Some(&c), [])?;
let f = StructType::with_finality_and_supertype(&engine, Finality::NonFinal, Some(&e), [])?;
let g = StructType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
None,
// Have to add a field so that `g` doesn't dedupe to `base`.
[field(HeapType::Any)],
)?;
let h = StructType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
Some(&g),
[field(HeapType::Any)],
)?;
let i = StructType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
Some(&h),
[field(HeapType::Any)],
)?;
for (expected, sub_name, sub, sup_name, sup) in [
// Identity, at root.
(true, "base", &base, "base", &base),
// Identity, in middle.
(true, "c", &c, "c", &c),
// Identity, at leaf.
(true, "f", &f, "f", &f),
// Direct, at root.
(true, "a", &a, "base", &base),
// Direct, in middle.
(true, "c", &c, "a", &a),
// Direct, at leaf.
(true, "f", &f, "e", &e),
// Transitive, at root.
(true, "c", &c, "base", &base),
// Transitive, in middle.
(true, "e", &e, "a", &a),
// Transitive, at leaf.
(true, "f", &f, "c", &c),
// Unrelated roots.
(false, "base", &base, "g", &g),
(false, "g", &g, "base", &base),
// Unrelated siblings.
(false, "a", &a, "b", &b),
(false, "b", &b, "a", &a),
(false, "c", &c, "d", &d),
(false, "d", &d, "c", &c),
// Unrelated root and middle.
(false, "base", &base, "h", &h),
(false, "h", &h, "base", &base),
// Unrelated root and leaf.
(false, "base", &base, "i", &i),
(false, "i", &i, "base", &base),
// Unrelated middles.
(false, "a", &a, "h", &h),
(false, "h", &h, "a", &a),
// Unrelated middle and leaf.
(false, "a", &a, "i", &i),
(false, "i", &i, "a", &a),
] {
eprintln!("expect that `{sub_name} <: {sup_name}` is `{expected}`");
let sub = HeapType::ConcreteStruct(sub.clone());
let sup = HeapType::ConcreteStruct(sup.clone());
let actual = sub.matches(&sup);
assert_eq!(expected, actual);
}
Ok(())
}
#[test]
fn array_subtyping_field_must_match() -> Result<()> {
let engine = Engine::default();
let a = ArrayType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
None,
imm_field(HeapType::Any),
)?;
for (expected, field) in [
// Non-matching field.
(false, imm_field(HeapType::Extern)),
// Wrong mutability field.
(false, field(HeapType::Any)),
// Exact match is okay.
(true, imm_field(HeapType::Any)),
// Subtype of the field is okay.
(true, imm_field(HeapType::Eq)),
] {
let actual =
ArrayType::with_finality_and_supertype(&engine, Finality::NonFinal, Some(&a), field)
.is_ok();
assert_eq!(expected, actual);
}
Ok(())
}
#[test]
fn array_subtyping_supertype_and_finality() -> Result<()> {
let engine = Engine::default();
for (expected, finality) in [(true, Finality::NonFinal), (false, Finality::Final)] {
let superty =
ArrayType::with_finality_and_supertype(&engine, finality, None, field(HeapType::Any))?;
let actual = ArrayType::with_finality_and_supertype(
&engine,
Finality::Final,
Some(&superty),
field(HeapType::Any),
)
.is_ok();
assert_eq!(expected, actual);
}
Ok(())
}
#[test]
fn array_subtyping() -> Result<()> {
let engine = Engine::default();
// These types produce the following trees:
//
// base g
// / \ /
// a b h
// / \ /
// c d i
// /
// e
// /
// f
let base = ArrayType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
None,
imm_field(HeapType::Any),
)?;
let a = ArrayType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
Some(&base),
imm_field(HeapType::Any),
)?;
let b = ArrayType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
Some(&base),
imm_field(HeapType::Eq),
)?;
let c = ArrayType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
Some(&a),
imm_field(HeapType::Any),
)?;
let d = ArrayType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
Some(&a),
imm_field(HeapType::Eq),
)?;
let e = ArrayType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
Some(&c),
imm_field(HeapType::Any),
)?;
let f = ArrayType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
Some(&e),
imm_field(HeapType::Any),
)?;
let g = ArrayType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
None,
imm_field(HeapType::Eq),
)?;
let h = ArrayType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
Some(&g),
imm_field(HeapType::Eq),
)?;
let i = ArrayType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
Some(&h),
imm_field(HeapType::Eq),
)?;
for (expected, sub_name, sub, sup_name, sup) in [
// Identity, at root.
(true, "base", &base, "base", &base),
// Identity, in middle.
(true, "c", &c, "c", &c),
// Identity, at leaf.
(true, "f", &f, "f", &f),
// Direct, at root.
(true, "a", &a, "base", &base),
// Direct, in middle.
(true, "c", &c, "a", &a),
// Direct, at leaf.
(true, "f", &f, "e", &e),
// Transitive, at root.
(true, "c", &c, "base", &base),
// Transitive, in middle.
(true, "e", &e, "a", &a),
// Transitive, at leaf.
(true, "f", &f, "c", &c),
// Unrelated roots.
(false, "base", &base, "g", &g),
(false, "g", &g, "base", &base),
// Unrelated siblings.
(false, "a", &a, "b", &b),
(false, "b", &b, "a", &a),
(false, "c", &c, "d", &d),
(false, "d", &d, "c", &c),
// Unrelated root and middle.
(false, "base", &base, "h", &h),
(false, "h", &h, "base", &base),
// Unrelated root and leaf.
(false, "base", &base, "i", &i),
(false, "i", &i, "base", &base),
// Unrelated middles.
(false, "a", &a, "h", &h),
(false, "h", &h, "a", &a),
// Unrelated middle and leaf.
(false, "a", &a, "i", &i),
(false, "i", &i, "a", &a),
] {
eprintln!("expect that `{sub_name} <: {sup_name}` is `{expected}`");
let sub = HeapType::ConcreteArray(sub.clone());
let sup = HeapType::ConcreteArray(sup.clone());
let actual = sub.matches(&sup);
assert_eq!(expected, actual);
}
Ok(())
}
#[test]
fn func_subtyping_field_must_match() -> Result<()> {
let engine = Engine::default();
let superty = FuncType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
None,
[valty(HeapType::Struct)],
[valty(HeapType::Any)],
)?;
for (expected, param, ret) in [
// Non-matching param type.
(false, valty(HeapType::Extern), valty(HeapType::Any)),
// Non-matching return type.
(false, valty(HeapType::Struct), valty(HeapType::Extern)),
// Exact match is okay.
(true, valty(HeapType::Struct), valty(HeapType::Any)),
// Subtype of the return type is okay.
(true, valty(HeapType::Struct), valty(HeapType::Eq)),
// Supertype of the param type is okay.
(true, valty(HeapType::Eq), valty(HeapType::Any)),
] {
let actual = FuncType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
Some(&superty),
[param],
[ret],
)
.is_ok();
assert_eq!(expected, actual);
}
Ok(())
}
#[test]
fn func_subtyping_supertype_and_finality() -> Result<()> {
let engine = Engine::default();
for (expected, finality) in [(true, Finality::NonFinal), (false, Finality::Final)] {
let superty = FuncType::with_finality_and_supertype(
&engine,
finality,
None,
[],
[valty(HeapType::Any)],
)?;
let actual = FuncType::with_finality_and_supertype(
&engine,
Finality::Final,
Some(&superty),
[],
[valty(HeapType::Any)],
)
.is_ok();
assert_eq!(expected, actual);
}
Ok(())
}
#[test]
fn func_subtyping() -> Result<()> {
let engine = Engine::default();
// These types produce the following trees:
//
// base g
// / \ /
// a b h
// / \ /
// c d i
// /
// e
// /
// f
let base = FuncType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
None,
[],
[valty(HeapType::Any)],
)?;
let a = FuncType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
Some(&base),
[],
[valty(HeapType::Any)],
)?;
let b = FuncType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
Some(&base),
[],
[valty(HeapType::Eq)],
)?;
let c = FuncType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
Some(&a),
[],
[valty(HeapType::Any)],
)?;
let d = FuncType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
Some(&a),
[],
[valty(HeapType::Eq)],
)?;
let e = FuncType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
Some(&c),
[],
[valty(HeapType::Any)],
)?;
let f = FuncType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
Some(&e),
[],
[valty(HeapType::Any)],
)?;
let g = FuncType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
None,
[],
[valty(HeapType::Eq)],
)?;
let h = FuncType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
Some(&g),
[],
[valty(HeapType::Eq)],
)?;
let i = FuncType::with_finality_and_supertype(
&engine,
Finality::NonFinal,
Some(&h),
[],
[valty(HeapType::Eq)],
)?;
for (expected, sub_name, sub, sup_name, sup) in [
// Identity, at root.
(true, "base", &base, "base", &base),
// Identity, in middle.
(true, "c", &c, "c", &c),
// Identity, at leaf.
(true, "f", &f, "f", &f),
// Direct, at root.
(true, "a", &a, "base", &base),
// Direct, in middle.
(true, "c", &c, "a", &a),
// Direct, at leaf.
(true, "f", &f, "e", &e),
// Transitive, at root.
(true, "c", &c, "base", &base),
// Transitive, in middle.
(true, "e", &e, "a", &a),
// Transitive, at leaf.
(true, "f", &f, "c", &c),
// Unrelated roots.
(false, "base", &base, "g", &g),
(false, "g", &g, "base", &base),
// Unrelated siblings.
(false, "a", &a, "b", &b),
(false, "b", &b, "a", &a),
(false, "c", &c, "d", &d),
(false, "d", &d, "c", &c),
// Unrelated root and middle.
(false, "base", &base, "h", &h),
(false, "h", &h, "base", &base),
// Unrelated root and leaf.
(false, "base", &base, "i", &i),
(false, "i", &i, "base", &base),
// Unrelated middles.
(false, "a", &a, "h", &h),
(false, "h", &h, "a", &a),
// Unrelated middle and leaf.
(false, "a", &a, "i", &i),
(false, "i", &i, "a", &a),
] {
eprintln!("expect that `{sub_name} <: {sup_name}` is `{expected}`");
assert_eq!(expected, sub.matches(sup));
let sub = HeapType::ConcreteFunc(sub.clone());
let sup = HeapType::ConcreteFunc(sup.clone());
let actual = sub.matches(&sup);
assert_eq!(expected, actual);
}
Ok(())
}
#[test]
fn heap_type_matches_noexn() -> Result<()> {
// Test that NoExn only matches exception-related types.
// NoExn should NOT match unrelated heap types like Func, Extern, Any, etc.
// NoExn should match exception hierarchy types
assert!(HeapType::NoExn.matches(&HeapType::Exn));
assert!(HeapType::NoExn.matches(&HeapType::NoExn));
// NoExn should NOT match types outside the exception hierarchy
assert!(!HeapType::NoExn.matches(&HeapType::Func));
assert!(!HeapType::NoExn.matches(&HeapType::NoFunc));
assert!(!HeapType::NoExn.matches(&HeapType::Extern));
assert!(!HeapType::NoExn.matches(&HeapType::NoExtern));
assert!(!HeapType::NoExn.matches(&HeapType::Any));
assert!(!HeapType::NoExn.matches(&HeapType::Eq));
assert!(!HeapType::NoExn.matches(&HeapType::I31));
assert!(!HeapType::NoExn.matches(&HeapType::Struct));
assert!(!HeapType::NoExn.matches(&HeapType::Array));
assert!(!HeapType::NoExn.matches(&HeapType::None));
assert!(!HeapType::NoExn.matches(&HeapType::Cont));
assert!(!HeapType::NoExn.matches(&HeapType::NoCont));
Ok(())
}
#[test]
#[cfg_attr(miri, ignore)]
/// Check that dropping a long guest-defined type from the registry doesn't
/// stack overflow.
fn drop_long_chain_of_guest_func_types() -> Result<()> {
// A chain of 20,000 function types where each type's parameter is a
// reference to the previous type.
const N: usize = 20_000;
let mut wat = String::from("(module\n (type $t0 (func))\n");
for i in 1..N {
wat.push_str(&format!(
" (type $t{i} (func (param (ref null $t{}))))\n",
i - 1
));
}
wat.push_str(&format!(
" (func (export \"f\") (type $t{}) unreachable)\n)\n",
N - 1
));
let mut config = Config::new();
config.wasm_function_references(true);
let engine = Engine::new(&config)?;
let module = Module::new(&engine, &wat)?;
let mut store = Store::new(&engine, ());
let instance = Instance::new(&mut store, &module, &[])?;
let trap = instance
.get_func(&mut store, "f")
.unwrap()
.call(&mut store, &[Val::FuncRef(None)], &mut [])
.unwrap_err()
.downcast::<Trap>()?;
assert_eq!(trap, Trap::UnreachableCodeReached);
Ok(())
}
#[test]
/// Check that dropping a long host-defined type from the registry doesn't stack
/// overflow.
fn drop_long_chain_of_host_func_types() -> Result<()> {
// Dropping the last type in a long chain of rec groups, each of which
// references the previous, should not overflow the stack.
let engine = Engine::default();
let mut ty = FuncType::new(&engine, [], []);
let amt = if cfg!(miri) { 10 } else { 100_000 };
for _ in 0..amt {
let param = ValType::Ref(RefType::new(true, HeapType::ConcreteFunc(ty)));
ty = FuncType::new(&engine, [param], []);
}
drop(ty);
Ok(())
}