Skip to content

A lightweight WebAssembly runtime that is fast, secure, and standards-compliant

62.6 KB
Raw Blame
#![cfg(not(miri))]

use wasmtime::Result;
use wasmtime::component::*;
use wasmtime::{Config, Engine, Store};

#[test]
fn host_resource_types() -> Result<()> {
    let engine = super::engine();
    let c = Component::new(
        &engine,
        r#"
            (component
                (import "t" (type $t (sub resource)))
                (import "u" (type $u (sub resource)))

                (export "t1" (type $t))
                (export "t2" (type $t))
                (export "u1" (type $u))
                (export "u2" (type $u))

                (component $c
                    (import "r" (type $r (sub resource)))
                    (export "r1" (type $r))
                )
                (instance $i1 (instantiate $c (with "r" (type $t))))
                (instance $i2 (instantiate $c (with "r" (type $t))))
                (export "t3" (type $i1 "r1"))
                (export "t4" (type $i2 "r1"))
            )
        "#,
    )?;

    struct T;
    struct U;
    assert!(ResourceType::host::<T>() != ResourceType::host::<U>());

    let mut store = Store::new(&engine, ());
    let mut linker = Linker::new(&engine);
    linker
        .root()
        .resource("t", ResourceType::host::<T>(), |_, _| Ok(()))?;
    linker
        .root()
        .resource("u", ResourceType::host::<U>(), |_, _| Ok(()))?;
    let i = linker.instantiate(&mut store, &c)?;
    let t1 = i.get_resource(&mut store, "t1").unwrap();
    let t2 = i.get_resource(&mut store, "t2").unwrap();
    let t3 = i.get_resource(&mut store, "t3").unwrap();
    let t4 = i.get_resource(&mut store, "t4").unwrap();
    let u1 = i.get_resource(&mut store, "u1").unwrap();
    let u2 = i.get_resource(&mut store, "u2").unwrap();

    assert_eq!(t1, ResourceType::host::<T>());
    assert_eq!(t2, ResourceType::host::<T>());
    assert_eq!(t3, ResourceType::host::<T>());
    assert_eq!(t4, ResourceType::host::<T>());
    assert_eq!(u1, ResourceType::host::<U>());
    assert_eq!(u2, ResourceType::host::<U>());
    Ok(())
}

#[test]
fn guest_resource_types() -> Result<()> {
    let engine = super::engine();
    let c = Component::new(
        &engine,
        r#"
            (component
                (type $t (resource (rep i32)))
                (type $u (resource (rep i32)))

                (export "t1" (type $t))
                (export "t2" (type $t))
                (export "u1" (type $u))
                (export "u2" (type $u))

                (component $c
                    (import "r" (type $r (sub resource)))
                    (export "r1" (type $r))
                )
                (instance $i1 (instantiate $c (with "r" (type $t))))
                (instance $i2 (instantiate $c (with "r" (type $t))))
                (export "t3" (type $i1 "r1"))
                (export "t4" (type $i2 "r1"))
            )
        "#,
    )?;

    let mut store = Store::new(&engine, ());
    let linker = Linker::new(&engine);
    let i = linker.instantiate(&mut store, &c)?;
    let t1 = i.get_resource(&mut store, "t1").unwrap();
    let t2 = i.get_resource(&mut store, "t2").unwrap();
    let t3 = i.get_resource(&mut store, "t3").unwrap();
    let t4 = i.get_resource(&mut store, "t4").unwrap();
    let u1 = i.get_resource(&mut store, "u1").unwrap();
    let u2 = i.get_resource(&mut store, "u2").unwrap();

    assert_ne!(t1, u1);
    assert_eq!(t1, t2);
    assert_eq!(t1, t3);
    assert_eq!(t1, t4);
    assert_eq!(u1, u2);
    Ok(())
}

#[test]
fn resource_any() -> Result<()> {
    let engine = super::engine();
    let c = Component::new(
        &engine,
        r#"
            (component
                (type $t' (resource (rep i32)))
                (type $u' (resource (rep i32)))

                (export $t "t" (type $t'))
                (export $u "u" (type $u'))

                (core func $t_ctor (canon resource.new $t))
                (core func $u_ctor (canon resource.new $u))

                (func (export "[constructor]t") (param "x" u32) (result (own $t))
                    (canon lift (core func $t_ctor)))
                (func (export "[constructor]u") (param "x" u32) (result (own $u))
                    (canon lift (core func $u_ctor)))

                (core func $t_drop (canon resource.drop $t))
                (core func $u_drop (canon resource.drop $u))

                (func (export "drop-t") (param "x" (own $t))
                    (canon lift (core func $t_drop)))
                (func (export "drop-u") (param "x" (own $u))
                    (canon lift (core func $u_drop)))
            )
        "#,
    )?;

    let linker = Linker::new(&engine);
    {
        let mut store = Store::new(&engine, ());
        let i = linker.instantiate(&mut store, &c)?;
        let t = i.get_resource(&mut store, "t").unwrap();
        let u = i.get_resource(&mut store, "u").unwrap();

        assert_ne!(t, u);

        let t_ctor = i.get_typed_func::<(u32,), (ResourceAny,)>(&mut store, "[constructor]t")?;
        let u_ctor = i.get_typed_func::<(u32,), (ResourceAny,)>(&mut store, "[constructor]u")?;
        let t_dtor = i.get_typed_func::<(ResourceAny,), ()>(&mut store, "drop-t")?;
        let u_dtor = i.get_typed_func::<(ResourceAny,), ()>(&mut store, "drop-u")?;

        let (t1,) = t_ctor.call(&mut store, (100,))?;
        let (t2,) = t_ctor.call(&mut store, (200,))?;
        let (u1,) = u_ctor.call(&mut store, (300,))?;
        let (u2,) = u_ctor.call(&mut store, (400,))?;

        assert_eq!(t1.ty(), t);
        assert_eq!(t2.ty(), t);
        assert_eq!(u1.ty(), u);
        assert_eq!(u2.ty(), u);

        u_dtor.call(&mut store, (u2,))?;

        u_dtor.call(&mut store, (u1,))?;

        t_dtor.call(&mut store, (t1,))?;

        t_dtor.call(&mut store, (t2,))?;
    }

    {
        let mut store = Store::new(&engine, ());
        let i = linker.instantiate(&mut store, &c)?;
        let t_ctor = i.get_typed_func::<(u32,), (ResourceAny,)>(&mut store, "[constructor]t")?;
        let u_ctor = i.get_typed_func::<(u32,), (ResourceAny,)>(&mut store, "[constructor]u")?;
        let t_dtor = i.get_typed_func::<(ResourceAny,), ()>(&mut store, "drop-t")?;

        // `t` is placed at host index 0
        let (t,) = t_ctor.call(&mut store, (100,))?;
        t_dtor.call(&mut store, (t,))?;

        // `u` is also placed at host index 0 since `t` was deallocated
        let (_u,) = u_ctor.call(&mut store, (100,))?;

        // reuse of `t` should fail, despite it pointing to a valid resource
        assert_eq!(
            t_dtor.call(&mut store, (t,)).unwrap_err().to_string(),
            "host-owned resource was already de-allocated"
        );
    }

    {
        let mut store = Store::new(&engine, ());
        let i = linker.instantiate(&mut store, &c)?;
        let t_ctor = i.get_typed_func::<(u32,), (ResourceAny,)>(&mut store, "[constructor]t")?;
        let t_dtor = i.get_typed_func::<(ResourceAny,), ()>(&mut store, "drop-t")?;

        // `t0` is placed at host index 0
        let (t0,) = t_ctor.call(&mut store, (100,))?;
        t_dtor.call(&mut store, (t0,))?;

        // `t1` is also placed at host index 0 since `t0` was deallocated
        let (_t1,) = t_ctor.call(&mut store, (100,))?;

        // reuse of `t0` should fail, despite it pointing to a valid resource
        assert_eq!(
            t_dtor.call(&mut store, (t0,)).unwrap_err().to_string(),
            "host-owned resource was already de-allocated"
        );
    }

    Ok(())
}

#[test]
fn mismatch_resource_types() -> Result<()> {
    let engine = super::engine();
    let c = Component::new(
        &engine,
        r#"
            (component
                (type $t' (resource (rep i32)))
                (type $u' (resource (rep i32)))

                (export $t "t" (type $t'))
                (export $u "u" (type $u'))

                (core func $t_ctor (canon resource.new $t))
                (func (export "ctor") (param "x" u32) (result (own $t))
                    (canon lift (core func $t_ctor)))

                (core func $u_dtor (canon resource.drop $u))
                (func (export "dtor") (param "x" (own $u))
                    (canon lift (core func $u_dtor)))
            )
        "#,
    )?;

    let mut store = Store::new(&engine, ());
    let i = Linker::new(&engine).instantiate(&mut store, &c)?;
    let ctor = i.get_typed_func::<(u32,), (ResourceAny,)>(&mut store, "ctor")?;
    let dtor = i.get_typed_func::<(ResourceAny,), ()>(&mut store, "dtor")?;

    let (t,) = ctor.call(&mut store, (100,))?;
    assert_eq!(
        dtor.call(&mut store, (t,)).unwrap_err().to_string(),
        "mismatched resource types"
    );

    Ok(())
}

#[test]
fn drop_guest_twice() -> Result<()> {
    let engine = super::engine();
    let c = Component::new(
        &engine,
        r#"
            (component
                (type $t' (resource (rep i32)))

                (export $t "t" (type $t'))

                (core func $ctor (canon resource.new $t))
                (func (export "ctor") (param "x" u32) (result (own $t))
                    (canon lift (core func $ctor)))

                (core func $dtor (canon resource.drop $t))
                (func (export "dtor") (param "x" (own $t))
                    (canon lift (core func $dtor)))
            )
        "#,
    )?;

    let mut store = Store::new(&engine, ());
    let i = Linker::new(&engine).instantiate(&mut store, &c)?;
    let ctor = i.get_typed_func::<(u32,), (ResourceAny,)>(&mut store, "ctor")?;
    let dtor = i.get_typed_func::<(&ResourceAny,), ()>(&mut store, "dtor")?;

    let (t,) = ctor.call(&mut store, (100,))?;
    dtor.call(&mut store, (&t,))?;

    assert_eq!(
        dtor.call(&mut store, (&t,)).unwrap_err().to_string(),
        "unknown handle index 1"
    );

    Ok(())
}

#[test]
fn drop_host_twice() -> Result<()> {
    let engine = super::engine();
    let c = Component::new(
        &engine,
        r#"
            (component
                (import "t" (type $t (sub resource)))

                (core func $dtor (canon resource.drop $t))
                (func (export "dtor") (param "x" (own $t))
                    (canon lift (core func $dtor)))
            )
        "#,
    )?;

    struct MyType;

    let mut store = Store::new(&engine, ());
    let mut linker = Linker::new(&engine);
    linker
        .root()
        .resource("t", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
    let i = linker.instantiate(&mut store, &c)?;
    let dtor = i.get_typed_func::<(&Resource<MyType>,), ()>(&mut store, "dtor")?;

    let t = Resource::new_own(100);
    dtor.call(&mut store, (&t,))?;

    assert_eq!(
        dtor.call(&mut store, (&t,)).unwrap_err().to_string(),
        "host resource already consumed"
    );

    Ok(())
}

#[test]
fn manually_destroy() -> Result<()> {
    let engine = super::engine();
    let c = Component::new(
        &engine,
        r#"
            (component
                (import "t1" (type $t1 (sub resource)))

                (core module $m
                  (global $drops (mut i32) i32.const 0)
                  (global $last-drop (mut i32) i32.const 0)

                  (func (export "dtor") (param i32)
                    (global.set $drops (i32.add (global.get $drops) (i32.const 1)))
                    (global.set $last-drop (local.get 0))
                  )
                  (func (export "drops") (result i32) global.get $drops)
                  (func (export "last-drop") (result i32) global.get $last-drop)
                  (func (export "pass") (param i32) (result i32) local.get 0)
                )
                (core instance $i (instantiate $m))
                (type $t2' (resource (rep i32) (dtor (core func $i "dtor"))))
                (export $t2 "t2" (type $t2'))
                (core func $ctor (canon resource.new $t2))
                (func (export "[constructor]t2") (param "rep" u32) (result (own $t2))
                  (canon lift (core func $ctor)))
                (func (export "[static]t2.drops") (result u32)
                  (canon lift (core func $i "drops")))
                (func (export "[static]t2.last-drop") (result u32)
                  (canon lift (core func $i "last-drop")))

                (func (export "t1-pass") (param "t" (own $t1)) (result (own $t1))
                  (canon lift (core func $i "pass")))
            )
        "#,
    )?;

    struct MyType;

    #[derive(Default)]
    struct Data {
        drops: u32,
        last_drop: Option<u32>,
    }

    let mut store = Store::new(&engine, Data::default());
    let mut linker = Linker::new(&engine);
    linker
        .root()
        .resource("t1", ResourceType::host::<MyType>(), |mut cx, rep| {
            let data: &mut Data = cx.data_mut();
            data.drops += 1;
            data.last_drop = Some(rep);
            Ok(())
        })?;
    let i = linker.instantiate(&mut store, &c)?;
    let t2_ctor = i.get_typed_func::<(u32,), (ResourceAny,)>(&mut store, "[constructor]t2")?;
    let t2_drops = i.get_typed_func::<(), (u32,)>(&mut store, "[static]t2.drops")?;
    let t2_last_drop = i.get_typed_func::<(), (u32,)>(&mut store, "[static]t2.last-drop")?;
    let t1_pass = i.get_typed_func::<(Resource<MyType>,), (ResourceAny,)>(&mut store, "t1-pass")?;

    // Host resources can be destroyed through `resource_drop`
    let t1 = Resource::new_own(100);
    let (t1,) = t1_pass.call(&mut store, (t1,))?;
    assert_eq!(store.data().drops, 0);
    assert_eq!(store.data().last_drop, None);
    t1.resource_drop(&mut store)?;
    assert_eq!(store.data().drops, 1);
    assert_eq!(store.data().last_drop, Some(100));

    // Guest resources can be destroyed through `resource_drop`
    let (t2,) = t2_ctor.call(&mut store, (200,))?;
    assert_eq!(t2_drops.call(&mut store, ())?, (0,));
    assert_eq!(t2_last_drop.call(&mut store, ())?, (0,));
    t2.resource_drop(&mut store)?;
    assert_eq!(t2_drops.call(&mut store, ())?, (1,));
    assert_eq!(t2_last_drop.call(&mut store, ())?, (200,));

    // Wires weren't crossed to drop more resources
    assert_eq!(store.data().drops, 1);
    assert_eq!(store.data().last_drop, Some(100));

    Ok(())
}

#[test]
fn dynamic_type() -> Result<()> {
    let engine = super::engine();
    let c = Component::new(
        &engine,
        r#"
            (component
                (import "t1" (type $t1 (sub resource)))
                (type $t2' (resource (rep i32)))
                (export $t2 "t2" (type $t2'))
                (core func $f (canon resource.drop $t2))

                (func (export "a") (param "x" (own $t1))
                    (canon lift (core func $f)))
                (func (export "b") (param "x" (tuple (own $t2)))
                    (canon lift (core func $f)))
            )
        "#,
    )?;

    struct MyType;

    let mut store = Store::new(&engine, ());
    let mut linker = Linker::new(&engine);
    linker
        .root()
        .resource("t1", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
    let i = linker.instantiate(&mut store, &c)?;

    let a = i.get_func(&mut store, "a").unwrap();
    let b = i.get_func(&mut store, "b").unwrap();
    let t2 = i.get_resource(&mut store, "t2").unwrap();

    let aty = a.ty(&store);
    assert_eq!(
        aty.params().next().unwrap(),
        ("x", Type::Own(ResourceType::host::<MyType>()))
    );
    let bty = b.ty(&store);
    match bty.params().next().unwrap() {
        (name, Type::Tuple(t)) => {
            assert_eq!(name, "x");
            assert_eq!(t.types().len(), 1);
            let t0 = t.types().next().unwrap();
            assert_eq!(t0, Type::Own(t2));
        }
        _ => unreachable!(),
    }

    Ok(())
}

#[test]
fn dynamic_val() -> Result<()> {
    let engine = super::engine();
    let c = Component::new(
        &engine,
        r#"
            (component
                (import "t1" (type $t1 (sub resource)))
                (type $t2' (resource (rep i32)))
                (export $t2 "t2" (type $t2'))
                (core func $f (canon resource.new $t2))

                (core module $m
                    (func (export "pass") (param i32) (result i32)
                        (local.get 0)))
                (core instance $i (instantiate $m))

                (func (export "a") (param "x" (own $t1)) (result (own $t1))
                    (canon lift (core func $i "pass")))
                (func (export "b") (param "x" u32) (result (own $t2))
                    (canon lift (core func $f)))
            )
        "#,
    )?;

    struct MyType;

    let mut store = Store::new(&engine, ());
    let mut linker = Linker::new(&engine);
    linker
        .root()
        .resource("t1", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
    let i_pre = linker.instantiate_pre(&c)?;
    let i = i_pre.instantiate(&mut store)?;

    let a = i.get_func(&mut store, "a").unwrap();
    let a_typed = i.get_typed_func::<(Resource<MyType>,), (ResourceAny,)>(&mut store, "a")?;
    let a_typed_result =
        i.get_typed_func::<(Resource<MyType>,), (Resource<MyType>,)>(&mut store, "a")?;
    let b = i.get_func(&mut store, "b").unwrap();
    let t2 = i.get_resource(&mut store, "t2").unwrap();

    let t1 = Resource::new_own(100);
    let (t1,) = a_typed.call(&mut store, (t1,))?;
    assert_eq!(t1.ty(), ResourceType::host::<MyType>());

    let mut results = [Val::Bool(false)];
    a.call(&mut store, &[Val::Resource(t1)], &mut results)?;
    match &results[0] {
        Val::Resource(resource) => {
            assert_eq!(resource.ty(), ResourceType::host::<MyType>());
            assert!(resource.owned());

            let resource = resource.try_into_resource::<MyType>(&mut store)?;
            assert_eq!(resource.rep(), 100);
            assert!(resource.owned());

            let resource = resource.try_into_resource_any(&mut store)?;
            assert_eq!(resource.ty(), ResourceType::host::<MyType>());
            assert!(resource.owned());
        }
        _ => unreachable!(),
    }

    let t1_any = Resource::<MyType>::new_own(100).try_into_resource_any(&mut store)?;
    let mut results = [Val::Bool(false)];
    a.call(&mut store, &[Val::Resource(t1_any)], &mut results)?;
    match &results[0] {
        Val::Resource(resource) => {
            assert_eq!(resource.ty(), ResourceType::host::<MyType>());
            assert!(resource.owned());

            let resource = resource.try_into_resource::<MyType>(&mut store)?;
            assert_eq!(resource.rep(), 100);
            assert!(resource.owned());

            let resource = resource.try_into_resource_any(&mut store)?;
            assert_eq!(resource.ty(), ResourceType::host::<MyType>());
            assert!(resource.owned());
        }
        _ => unreachable!(),
    }

    let t1 = Resource::<MyType>::new_own(100)
        .try_into_resource_any(&mut store)?
        .try_into_resource(&mut store)?;
    let (t1,) = a_typed_result.call(&mut store, (t1,))?;
    assert_eq!(t1.rep(), 100);
    assert!(t1.owned());

    let t1_any = t1
        .try_into_resource_any(&mut store)?
        .try_into_resource::<MyType>(&mut store)?
        .try_into_resource_any(&mut store)?;
    let mut results = [Val::Bool(false)];
    a.call(&mut store, &[Val::Resource(t1_any)], &mut results)?;
    match &results[0] {
        Val::Resource(resource) => {
            assert_eq!(resource.ty(), ResourceType::host::<MyType>());
            assert!(resource.owned());

            let resource = resource.try_into_resource::<MyType>(&mut store)?;
            assert_eq!(resource.rep(), 100);
            assert!(resource.owned());

            let resource = resource.try_into_resource_any(&mut store)?;
            assert_eq!(resource.ty(), ResourceType::host::<MyType>());
            assert!(resource.owned());
        }
        _ => unreachable!(),
    }

    b.call(&mut store, &[Val::U32(200)], &mut results)?;
    match &results[0] {
        Val::Resource(resource) => {
            assert_eq!(resource.ty(), t2);
        }
        _ => unreachable!(),
    }

    Ok(())
}

#[test]
fn reenter_during_import() -> Result<()> {
    let engine = super::engine();
    let c = Component::new(
        &engine,
        r#"
            (component
                (import "f" (func $f))

                (core func $f (canon lower (func $f)))

                (core module $m
                    (import "" "f" (func $f))
                    (func (export "call") call $f)
                    (func (export "dtor") (param i32))
                )

                (core instance $i (instantiate $m
                    (with "" (instance
                        (export "f" (func $f))
                    ))
                ))

                (type $t2' (resource (rep i32) (dtor (core func $i "dtor"))))
                (export $t2 "t" (type $t2'))
                (core func $ctor (canon resource.new $t2))
                (func (export "ctor") (param "x" u32) (result (own $t2))
                    (canon lift (core func $ctor)))

                (func (export "call") (canon lift (core func $i "call")))
            )
        "#,
    )?;

    let mut store = Store::new(&engine, None);
    let mut linker = Linker::new(&engine);
    linker.root().func_wrap("f", |mut cx, ()| {
        let data: &mut Option<ResourceAny> = cx.data_mut();
        data.take().unwrap().resource_drop(cx)?;
        Ok(())
    })?;
    let i = linker.instantiate(&mut store, &c)?;

    let ctor = i.get_typed_func::<(u32,), (ResourceAny,)>(&mut store, "ctor")?;
    let call = i.get_typed_func::<(), ()>(&mut store, "call")?;

    let (resource,) = ctor.call(&mut store, (100,))?;
    *store.data_mut() = Some(resource);
    call.call(&mut store, ())?;

    Ok(())
}

#[test]
fn borrows_must_be_dropped_before_lifting() -> Result<()> {
    let engine = super::engine();
    let c = Component::new(
        &engine,
        r#"
            (component
                (import "t" (type $t (sub resource)))

                (core module $m
                    (func (export "f") (param i32) (result i32)
                        ;; this is a `borrow $t`, and we're returning it as an
                        ;; `own $t`. This should have an error about remaining
                        ;; borrows rather than a mismatch of own/borrow.
                        local.get 0
                    )
                )
                (core instance $i (instantiate $m))

                (func (export "f") (param "x" (borrow $t)) (result (own $t))
                    (canon lift (core func $i "f")))
            )
        "#,
    )?;

    struct MyType;

    let mut store = Store::new(&engine, ());
    let mut linker = Linker::new(&engine);
    linker
        .root()
        .resource("t", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
    let i = linker.instantiate(&mut store, &c)?;

    let f = i.get_typed_func::<(&Resource<MyType>,), (Resource<MyType>,)>(&mut store, "f")?;

    let resource = Resource::new_own(100);
    let err = f.call(&mut store, (&resource,)).unwrap_err();
    assert_eq!(
        err.to_string(),
        "borrow handles still remain at the end of the call"
    );
    Ok(())
}

#[test]
fn can_use_own_for_borrow() -> Result<()> {
    let engine = super::engine();
    let c = Component::new(
        &engine,
        r#"
            (component
                (import "t" (type $t (sub resource)))

                (core func $drop (canon resource.drop $t))

                (core module $m
                    (import "" "drop" (func $drop (param i32)))
                    (func (export "f") (param i32)
                        (call $drop (local.get 0))
                    )
                    (func (export "forget") (param i32))
                )
                (core instance $i (instantiate $m
                    (with "" (instance
                        (export "drop" (func $drop))
                    ))
                ))

                (func (export "f") (param "x" (borrow $t))
                    (canon lift (core func $i "f")))
                (func (export "forget") (param "x" (borrow $t))
                    (canon lift (core func $i "forget")))
                (func (export "own") (param "x" (own $t))
                    (canon lift (core func $i "f")))
            )
        "#,
    )?;

    struct MyType;

    let mut store = Store::new(&engine, ());
    let mut linker = Linker::new(&engine);
    linker
        .root()
        .resource("t", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
    let i_pre = linker.instantiate_pre(&c)?;
    let i = i_pre.instantiate(&mut store)?;

    let f = i.get_func(&mut store, "f").unwrap();
    let f_typed = i.get_typed_func::<(&Resource<MyType>,), ()>(&mut store, "f")?;

    let resource = Resource::new_own(100);
    f_typed.call(&mut store, (&resource,))?;

    let resource = Resource::new_borrow(200);
    f_typed.call(&mut store, (&resource,))?;

    let resource = Resource::<MyType>::new_own(300).try_into_resource_any(&mut store)?;
    f.call(&mut store, &[Val::Resource(resource)], &mut [])?;
    resource.resource_drop(&mut store)?;

    let resource = Resource::<MyType>::new_borrow(400).try_into_resource_any(&mut store)?;
    assert!(!resource.owned());
    assert_eq!(resource.ty(), ResourceType::host::<MyType>());

    struct OtherType;
    assert!(resource.try_into_resource::<OtherType>(&mut store).is_err());

    let typed = resource.try_into_resource::<MyType>(&mut store)?;
    assert!(!typed.owned());
    assert_eq!(typed.rep(), 400);
    let resource = typed.try_into_resource_any(&mut store)?;
    f.call(&mut store, &[Val::Resource(resource)], &mut [])?;
    resource.resource_drop(&mut store)?;

    let mut own_store = Store::new(&engine, ());
    let own_instance = i_pre.instantiate(&mut own_store)?;
    let own = own_instance.get_func(&mut own_store, "own").unwrap();
    let err = own
        .call(&mut own_store, &[Val::Resource(resource)], &mut [])
        .unwrap_err();
    assert!(
        format!("{err:?}").contains("cannot lower a `borrow` resource into an `own`"),
        "bad error: {err:?}",
    );

    let forget = i.get_func(&mut store, "forget").unwrap();
    let err = forget
        .call(&mut store, &[Val::Resource(resource)], &mut [])
        .unwrap_err();
    assert_eq!(
        err.to_string(),
        "borrow handles still remain at the end of the call"
    );

    Ok(())
}

#[test]
fn passthrough_wrong_type() -> Result<()> {
    let engine = super::engine();
    let c = Component::new(
        &engine,
        r#"
            (component
                (import "t" (type $t (sub resource)))
                (import "f" (func $f (param "a" (borrow $t)) (result (own $t))))

                (core func $f (canon lower (func $f)))

                (core module $m
                    (import "" "f" (func $f (param i32) (result i32)))
                    (func (export "f2") (param i32)
                        (drop (call $f (local.get 0)))
                    )
                )
                (core instance $i (instantiate $m
                    (with "" (instance
                        (export "f" (func $f))
                    ))
                ))

                (func (export "f2") (param "x" (borrow $t))
                    (canon lift (core func $i "f2")))
            )
        "#,
    )?;

    struct MyType;

    let mut store = Store::new(&engine, ());
    let mut linker = Linker::new(&engine);
    linker
        .root()
        .resource("t", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
    linker
        .root()
        .func_wrap("f", |_cx, (r,): (Resource<MyType>,)| Ok((r,)))?;
    let i = linker.instantiate(&mut store, &c)?;

    let f = i.get_typed_func::<(&Resource<MyType>,), ()>(&mut store, "f2")?;

    let resource = Resource::new_own(100);
    let err = f.call(&mut store, (&resource,)).unwrap_err();
    assert!(
        format!("{err:?}").contains("cannot lower a `borrow` resource into an `own`"),
        "bad error: {err:?}"
    );
    Ok(())
}

#[test]
fn pass_moved_resource() -> Result<()> {
    let engine = super::engine();
    let c = Component::new(
        &engine,
        r#"
            (component
                (import "t" (type $t (sub resource)))
                (core module $m
                    (func (export "f") (param i32 i32))
                )
                (core instance $i (instantiate $m))

                (func (export "f") (param "x" (own $t)) (param "y" (borrow $t))
                    (canon lift (core func $i "f")))
            )
        "#,
    )?;

    struct MyType;

    let mut store = Store::new(&engine, ());
    let mut linker = Linker::new(&engine);
    linker
        .root()
        .resource("t", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
    let i = linker.instantiate(&mut store, &c)?;

    let f = i.get_typed_func::<(&Resource<MyType>, &Resource<MyType>), ()>(&mut store, "f")?;

    let resource = Resource::new_own(100);
    let err = f.call(&mut store, (&resource, &resource)).unwrap_err();
    assert!(
        format!("{err:?}").contains("host resource already consumed"),
        "bad error: {err:?}"
    );
    Ok(())
}

#[test]
fn type_mismatch() -> Result<()> {
    let engine = super::engine();
    let c = Component::new(
        &engine,
        r#"
            (component
                (type $t' (resource (rep i32)))
                (export $t "t" (type $t'))

                (core func $drop (canon resource.drop $t))

                (func (export "f1") (param "x" (own $t))
                    (canon lift (core func $drop)))
                (func (export "f2") (param "x" (borrow $t))
                    (canon lift (core func $drop)))
                (func (export "f3") (param "x" u32)
                    (canon lift (core func $drop)))
            )
        "#,
    )?;

    struct MyType;

    let mut store = Store::new(&engine, ());
    let i = Linker::new(&engine).instantiate(&mut store, &c)?;

    assert!(
        i.get_typed_func::<(&Resource<MyType>,), ()>(&mut store, "f1")
            .is_err()
    );
    assert!(
        i.get_typed_func::<(&ResourceAny,), ()>(&mut store, "f1")
            .is_ok()
    );

    assert!(
        i.get_typed_func::<(&Resource<MyType>,), ()>(&mut store, "f2")
            .is_err()
    );
    assert!(
        i.get_typed_func::<(&ResourceAny,), ()>(&mut store, "f2")
            .is_ok()
    );

    assert!(
        i.get_typed_func::<(&Resource<MyType>,), ()>(&mut store, "f3")
            .is_err()
    );
    assert!(
        i.get_typed_func::<(&ResourceAny,), ()>(&mut store, "f3")
            .is_err()
    );
    assert!(i.get_typed_func::<(u32,), ()>(&mut store, "f3").is_ok());

    Ok(())
}

#[test]
fn drop_no_dtor() -> Result<()> {
    let engine = super::engine();
    let c = Component::new(
        &engine,
        r#"
            (component
                (type $t' (resource (rep i32)))
                (export $t "t" (type $t'))

                (core func $ctor (canon resource.new $t))

                (func (export "ctor") (param "x" u32) (result (own $t))
                    (canon lift (core func $ctor)))
            )
        "#,
    )?;

    let mut store = Store::new(&engine, ());
    let i = Linker::new(&engine).instantiate(&mut store, &c)?;
    let ctor = i.get_typed_func::<(u32,), (ResourceAny,)>(&mut store, "ctor")?;
    let (resource,) = ctor.call(&mut store, (100,))?;
    resource.resource_drop(&mut store)?;

    Ok(())
}

#[test]
fn host_borrow_as_resource_any() -> Result<()> {
    let engine = super::engine();
    let c = Component::new(
        &engine,
        r#"
            (component
                (import "t" (type $t (sub resource)))
                (import "f" (func $f (param "f" (borrow $t))))

                (core func $f (canon lower (func $f)))
                (core func $drop (canon resource.drop $t))

                (core module $m
                    (import "" "f" (func $f (param i32)))
                    (import "" "drop" (func $drop (param i32)))
                    (func (export "f2") (param i32)
                        (call $f (local.get 0))
                        (call $drop (local.get 0))
                    )
                )
                (core instance $i (instantiate $m
                    (with "" (instance
                        (export "f" (func $f))
                        (export "drop" (func $drop))
                    ))
                ))

                (func (export "f2") (param "x" (borrow $t))
                    (canon lift (core func $i "f2")))
            )
        "#,
    )?;

    struct MyType;

    let mut store = Store::new(&engine, ());

    // First test the above component where the host properly drops the argument
    {
        let mut linker = Linker::new(&engine);
        linker
            .root()
            .resource("t", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
        linker
            .root()
            .func_wrap("f", |mut cx, (r,): (ResourceAny,)| {
                r.resource_drop(&mut cx)?;
                Ok(())
            })?;
        let i = linker.instantiate(&mut store, &c)?;

        let f = i.get_typed_func::<(&Resource<MyType>,), ()>(&mut store, "f2")?;

        let resource = Resource::new_own(100);
        f.call(&mut store, (&resource,))?;
    }

    // Then also test the case where the host forgets a drop
    {
        let mut linker = Linker::new(&engine);
        linker
            .root()
            .resource("t", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
        linker.root().func_wrap("f", |_cx, (_r,): (ResourceAny,)| {
            // ... no drop here
            Ok(())
        })?;
        let i = linker.instantiate(&mut store, &c)?;

        let f = i.get_typed_func::<(&Resource<MyType>,), ()>(&mut store, "f2")?;

        let resource = Resource::new_own(100);
        let err = f.call(&mut store, (&resource,)).unwrap_err();
        assert!(
            format!("{err:?}").contains("borrow handles still remain at the end of the call"),
            "bad error: {err:?}"
        );
    }
    Ok(())
}

#[test]
fn pass_guest_back_as_borrow() -> Result<()> {
    let engine = super::engine();
    let c = Component::new(
        &engine,
        r#"
            (component
                (type $t' (resource (rep i32)))

                (export $t "t" (type $t'))

                (core func $new (canon resource.new $t))

                (core module $m
                    (import "" "new" (func $new (param i32) (result i32)))

                    (func (export "mk") (result i32)
                        (call $new (i32.const 100))
                    )

                    (func (export "take") (param i32)
                        (if (i32.ne (local.get 0) (i32.const 100)) (then (unreachable)))
                    )
                )
                (core instance $i (instantiate $m
                    (with "" (instance
                        (export "new" (func $new))
                    ))
                ))

                (func (export "mk") (result (own $t))
                    (canon lift (core func $i "mk")))
                (func (export "take") (param "x" (borrow $t))
                    (canon lift (core func $i "take")))
            )
        "#,
    )?;

    let mut store = Store::new(&engine, ());
    let i = Linker::new(&engine).instantiate(&mut store, &c)?;
    let mk = i.get_typed_func::<(), (ResourceAny,)>(&mut store, "mk")?;
    let take = i.get_typed_func::<(&ResourceAny,), ()>(&mut store, "take")?;

    let (resource,) = mk.call(&mut store, ())?;
    take.call(&mut store, (&resource,))?;

    resource.resource_drop(&mut store)?;

    // Should not be valid to use `resource` again
    let err = take.call(&mut store, (&resource,)).unwrap_err();
    assert_eq!(err.to_string(), "unknown handle index 1");

    Ok(())
}

#[test]
fn pass_host_borrow_to_guest() -> Result<()> {
    let engine = super::engine();
    let c = Component::new(
        &engine,
        r#"
            (component
                (import "t" (type $t (sub resource)))

                (core func $drop (canon resource.drop $t))

                (core module $m
                    (import "" "drop" (func $drop (param i32)))
                    (func (export "take") (param i32)
                      (call $drop (local.get 0))
                    )
                )
                (core instance $i (instantiate $m
                    (with "" (instance
                        (export "drop" (func $drop))
                    ))
                ))

                (func (export "take") (param "x" (borrow $t))
                    (canon lift (core func $i "take")))
            )
        "#,
    )?;

    struct MyType;

    let mut store = Store::new(&engine, ());
    let mut linker = Linker::new(&engine);
    linker
        .root()
        .resource("t", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
    let i = linker.instantiate(&mut store, &c)?;
    let take = i.get_typed_func::<(&Resource<MyType>,), ()>(&mut store, "take")?;

    let resource = Resource::new_borrow(100);
    take.call(&mut store, (&resource,))?;

    Ok(())
}

#[test]
fn guest_different_host_same() -> Result<()> {
    let engine = super::engine();
    let c = Component::new(
        &engine,
        r#"
            (component
                (import "t1" (type $t1 (sub resource)))
                (import "t2" (type $t2 (sub resource)))

                (import "f" (func $f (param "a" (borrow $t1)) (param "b" (borrow $t2))))

                (export $g1 "g1" (type $t1))
                (export $g2 "g2" (type $t2))

                (core func $f (canon lower (func $f)))
                (core func $drop1 (canon resource.drop $t1))
                (core func $drop2 (canon resource.drop $t2))

                (core module $m
                    (import "" "f" (func $f (param i32 i32)))
                    (import "" "drop1" (func $drop1 (param i32)))
                    (import "" "drop2" (func $drop2 (param i32)))

                    (func (export "f") (param i32 i32)
                        ;; different types, but everything goes into the same
                        ;; handle index namespace
                        (if (i32.ne (local.get 0) (i32.const 1)) (then (unreachable)))
                        (if (i32.ne (local.get 1) (i32.const 2)) (then (unreachable)))

                        ;; host should end up getting the same resource
                        (call $f (local.get 0) (local.get 1))

                        ;; drop our borrows
                        (call $drop1 (local.get 0))
                        (call $drop2 (local.get 1))
                    )
                )
                (core instance $i (instantiate $m
                    (with "" (instance
                        (export "f" (func $f))
                        (export "drop1" (func $drop1))
                        (export "drop2" (func $drop2))
                    ))
                ))

                (func (export "f2") (param "a" (borrow $g1)) (param "b" (borrow $g2))
                    (canon lift (core func $i "f")))
            )
        "#,
    )?;

    struct MyType;

    let mut store = Store::new(&engine, ());
    let mut linker = Linker::new(&engine);
    linker
        .root()
        .resource("t1", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
    linker
        .root()
        .resource("t2", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
    linker.root().func_wrap(
        "f",
        |_cx, (r1, r2): (Resource<MyType>, Resource<MyType>)| {
            assert!(!r1.owned());
            assert!(!r2.owned());
            assert_eq!(r1.rep(), 100);
            assert_eq!(r2.rep(), 100);
            Ok(())
        },
    )?;
    let i = linker.instantiate(&mut store, &c)?;
    let f = i.get_typed_func::<(&Resource<MyType>, &Resource<MyType>), ()>(&mut store, "f2")?;

    let t1 = i.get_resource(&mut store, "g1").unwrap();
    let t2 = i.get_resource(&mut store, "g2").unwrap();
    assert_eq!(t1, t2);
    assert_eq!(t1, ResourceType::host::<MyType>());

    let resource = Resource::new_own(100);
    f.call(&mut store, (&resource, &resource))?;

    Ok(())
}

#[test]
fn resource_any_to_typed_handles_borrow() -> Result<()> {
    let engine = super::engine();
    let c = Component::new(
        &engine,
        r#"
            (component
                (import "t" (type $t (sub resource)))

                (import "f" (func $f (param "a" (borrow $t))))

                (core func $f (canon lower (func $f)))

                (core module $m
                    (import "" "f" (func $f (param i32)))

                    (func (export "f") (param i32)
                        (call $f (local.get 0))
                    )
                )
                (core instance $i (instantiate $m
                    (with "" (instance
                        (export "f" (func $f))
                    ))
                ))

                (func (export "f") (param "a" (own $t))
                    (canon lift (core func $i "f")))
            )
        "#,
    )?;

    struct MyType;

    let mut store = Store::new(&engine, ());
    let mut linker = Linker::new(&engine);
    linker
        .root()
        .resource("t", ResourceType::host::<MyType>(), |_, _| Ok(()))?;
    linker
        .root()
        .func_wrap("f", |mut cx, (r,): (ResourceAny,)| {
            let r = r.try_into_resource::<MyType>(&mut cx).unwrap();
            assert_eq!(r.rep(), 100);
            assert!(!r.owned());
            Ok(())
        })?;
    let i = linker.instantiate(&mut store, &c)?;
    let f = i.get_typed_func::<(&Resource<MyType>,), ()>(&mut store, "f")?;

    let resource = Resource::new_own(100);
    f.call(&mut store, (&resource,))?;

    Ok(())
}

#[test]
fn resource_dynamic() -> Result<()> {
    let r = ResourceDynamic::new_own(1, 2);
    assert_eq!(r.rep(), 1);
    assert!(r.owned());
    assert_eq!(r.ty(), 2);

    let engine = super::engine();
    let mut store = Store::new(&engine, ());

    let r2 = r.try_into_resource_any(&mut store)?;
    assert_eq!(r2.ty(), ResourceType::host_dynamic(2));
    assert!(r2.owned());

    let r3 = r2.try_into_resource_dynamic(&mut store)?;
    assert_eq!(r3.rep(), 1);
    assert_eq!(r3.ty(), 2);

    let borrowed = ResourceDynamic::new_borrow(4, 2).try_into_resource_any(&mut store)?;
    assert!(!borrowed.owned());
    assert_eq!(borrowed.ty(), ResourceType::host_dynamic(2));
    let borrowed_again = borrowed.try_into_resource_dynamic(&mut store)?;
    assert!(!borrowed_again.owned());
    assert_eq!(borrowed_again.rep(), 4);
    assert_eq!(borrowed_again.ty(), 2);

    let c = Component::new(
        &engine,
        r#"
            (component
                (import "t" (type $t (sub resource)))
                (import "u" (type $u (sub resource)))

                (core func $t_drop (canon resource.drop $t))
                (core func $u_drop (canon resource.drop $u))

                (func (export "drop-t") (param "x" (own $t))
                    (canon lift (core func $t_drop)))
                (func (export "borrow-t") (param "x" (borrow $t))
                    (canon lift (core func $t_drop)))
                (func (export "drop-u") (param "x" (own $u))
                    (canon lift (core func $u_drop)))
            )
        "#,
    )?;
    let mut linker = Linker::new(&engine);
    linker
        .root()
        .resource("t", ResourceType::host_dynamic(2), |_, _| Ok(()))?;
    linker
        .root()
        .resource("u", ResourceType::host_dynamic(3), |_, _| Ok(()))?;
    let instance = linker.instantiate(&mut store, &c)?;

    let drop_t = instance.get_typed_func::<(ResourceDynamic,), ()>(&mut store, "drop-t")?;
    let borrow_t = instance.get_func(&mut store, "borrow-t").unwrap();
    let drop_u = instance.get_typed_func::<(ResourceDynamic,), ()>(&mut store, "drop-u")?;

    let borrowed = ResourceDynamic::new_borrow(5, 2).try_into_resource_any(&mut store)?;
    borrow_t.call(&mut store, &[Val::Resource(borrowed)], &mut [])?;
    borrowed.resource_drop(&mut store)?;

    drop_t.call(&mut store, (ResourceDynamic::new_own(1, 2),))?;

    drop_u.call(&mut store, (ResourceDynamic::new_own(2, 3),))?;

    assert!(
        drop_t
            .call(&mut store, (ResourceDynamic::new_own(1, 1),))
            .is_err()
    );

    Ok(())
}

#[test]
fn resource_dynamic_not_static() -> Result<()> {
    let engine = super::engine();
    let mut store = Store::new(&engine, ());
    let c = Component::new(
        &engine,
        r#"
            (component
                (import "t" (type $t (sub resource)))
                (core func $t_drop (canon resource.drop $t))
                (func (export "drop-t") (param "x" (own $t))
                    (canon lift (core func $t_drop)))
            )
        "#,
    )?;

    struct T;

    {
        let mut linker = Linker::new(&engine);
        linker
            .root()
            .resource("t", ResourceType::host_dynamic(2), |_, _| Ok(()))?;
        let instance = linker.instantiate(&mut store, &c)?;
        instance.get_typed_func::<(ResourceDynamic,), ()>(&mut store, "drop-t")?;
        assert!(
            instance
                .get_typed_func::<(Resource<T>,), ()>(&mut store, "drop-t")
                .is_err()
        );
    }

    {
        let mut linker = Linker::new(&engine);
        linker
            .root()
            .resource("t", ResourceType::host::<T>(), |_, _| Ok(()))?;
        let instance = linker.instantiate(&mut store, &c)?;
        assert!(
            instance
                .get_typed_func::<(ResourceDynamic,), ()>(&mut store, "drop-t")
                .is_err()
        );
        instance.get_typed_func::<(Resource<T>,), ()>(&mut store, "drop-t")?;
    }

    Ok(())
}

#[tokio::test]
async fn drop_after_sync_lowered_async_host_function() -> Result<()> {
    let mut config = Config::new();
    config.wasm_component_model_async(true);
    let engine = Engine::new(&config)?;
    let mut store = Store::new(&engine, ());
    let mut linker = Linker::new(&engine);
    let c = Component::new(
        &engine,
        r#"
(component
  (import "r" (type $r (sub resource)))
  ;;(import "f" (func $f async (param "x" (borrow $r)) (param "y" (borrow $r))))
  ;;(import "n" (func $n (result (own $r))))
  (import "f" (func $f async))


  (component $A
    (import "f" (func $f async))
    (core module $m
      (import "" "f" (func $f))
      (func (export "call") (result i32) call $f i32.const 0)
      (func (export "cb") (param i32 i32 i32) (result i32) unreachable)
    )
    (core func $f (canon lower (func $f)))
    (core instance $i (instantiate $m
        (with "" (instance (export "f" (func $f))))
    ))
    (func (export "call") async
      (canon lift (core func $i "call")
        async
        (callback (core func $i "cb"))))
  )

  (component $B
    (import "r" (type $r (sub resource)))
    (import "f" (func $f async))
    (core module $m
      (import "" "f" (func $f (result i32)))
      (import "" "r" (func $r))
      (import "" "drop" (func $drop (param i32)))
      (func (export "call") (param i32) (result i32)
        ;; Call into component `$A` which is an async-lifted function. This
        ;; function will call a sync-lowered async function from the host. In
        ;; effect this means that the task started here by calling `$f` is
        ;; blocked.
        call $f
        drop ;; ignore the `SUBTASK_STARTED` status code

        ;; Now drop our borrow that this function was provided. This is
        ;; entirely disconnected from `$A` and it should be using the borrow
        ;; tracking of this task, no other task.
        (call $drop (local.get 0))

        ;; Now finish up this task without actually waiting on `$A`.
        call $r
        i32.const 0
      )
      (func (export "cb") (param i32 i32 i32) (result i32) unreachable)
    )
    (core func $f (canon lower (func $f) async))
    (core func $r (canon task.return))
    (core func $drop (canon resource.drop $r))
    (core instance $i (instantiate $m
      (with "" (instance
        (export "f" (func $f))
        (export "r" (func $r))
        (export "drop" (func $drop))
      ))
    ))
    (func (export "call") async (param "x" (borrow $r))
        (canon lift (core func $i "call")
            async
            (callback (core func $i "cb"))))
  )
  (instance $a (instantiate $A (with "f" (func $f))))
  (instance $b (instantiate $B
    (with "f" (func $a "call"))
    (with "r" (type $r))
))
  (export "call" (func $b "call"))
)
"#,
    )?;

    let mut root = linker.root();
    root.resource("r", ResourceType::host::<u32>(), |_, _| Ok(()))?;
    root.func_wrap_concurrent("f", |_accessor, ()| {
        Box::pin(async move { std::future::pending::<Result<()>>().await })
    })?;

    let i = linker.instantiate_async(&mut store, &c).await?;
    let call = i.get_typed_func::<(Resource<u32>,), ()>(&mut store, "call")?;
    let r = Resource::new_borrow(3);
    call.call_async(&mut store, (r,)).await?;
    Ok(())
}

mod host_call_cleans_up_borrow {
    use super::*;

    #[derive(Clone, Copy, Debug)]
    enum HostAction {
        Yield,
        CallWasm,
    }

    #[derive(Default)]
    struct State {
        instance: Option<Instance>,
        dropped: bool,
    }

    struct MyType;

    #[tokio::test]
    async fn host_borrow_yield_and_call_wasm_valid() -> Result<()> {
        run(&[]).await?;
        run(&[HostAction::Yield]).await?;
        run(&[HostAction::CallWasm]).await?;
        run(&[HostAction::Yield, HostAction::Yield]).await?;
        run(&[HostAction::Yield, HostAction::CallWasm]).await?;
        run(&[HostAction::CallWasm, HostAction::Yield]).await?;
        run(&[HostAction::CallWasm, HostAction::CallWasm]).await?;
        run(&[
            HostAction::CallWasm,
            HostAction::Yield,
            HostAction::CallWasm,
        ])
        .await?;
        run(&[HostAction::Yield, HostAction::CallWasm, HostAction::Yield]).await?;
        Ok(())
    }

    async fn run(actions: &'static [HostAction]) -> Result<()> {
        let mut config = Config::new();
        config.wasm_component_model_async(true);
        let engine = Engine::new(&config)?;
        let component = Component::new(
            &engine,
            r#"
                (component
                    (import "r" (type $r (sub resource)))
                    (import "new" (func $new (result (own $r))))
                    (import "borrow" (func $borrow async (param "r" (borrow $r))))

                    (core func $new (canon lower (func $new)))
                    (core func $borrow (canon lower (func $borrow) async))
                    (core func $drop (canon resource.drop $r))
                    (core func $task-return (canon task.return))
                    (core func $waitable-set-new (canon waitable-set.new))
                    (core func $waitable-set-drop (canon waitable-set.drop))
                    (core func $waitable-join (canon waitable.join))
                    (core func $subtask-drop (canon subtask.drop))

                    (core module $m
                        (import "" "new" (func $new (result i32)))
                        (import "" "borrow" (func $borrow (param i32) (result i32)))
                        (import "" "drop" (func $drop (param i32)))
                        (import "" "task-return" (func $task-return))
                        (import "" "waitable-set-new" (func $waitable-set-new (result i32)))
                        (import "" "waitable-set-drop" (func $waitable-set-drop (param i32)))
                        (import "" "waitable-join" (func $waitable-join (param i32 i32)))
                        (import "" "subtask-drop" (func $subtask-drop (param i32)))

                        (global $r (mut i32) (i32.const 0))
                        (global $set (mut i32) (i32.const 0))
                        (global $subtask (mut i32) (i32.const 0))

                        (func $finish
                            ;; This succeeds only if returning from `borrow`
                            ;; restored the lend count on the owned handle.
                            (call $drop (global.get $r))
                            (call $waitable-set-drop (global.get $set))
                            call $task-return)

                        (func (export "run") (result i32)
                            (local $status i32)
                            (global.set $r (call $new))
                            (global.set $set (call $waitable-set-new))
                            (local.set $status (call $borrow (global.get $r)))
                            (if (i32.eq
                                    (i32.and (local.get $status) (i32.const 0xf))
                                    (i32.const 2 (; RETURNED ;)))
                                (then
                                    call $finish
                                    (return (i32.const 0 (; EXIT ;)))))
                            (if (i32.ne
                                    (i32.and (local.get $status) (i32.const 0xf))
                                    (i32.const 1 (; STARTED ;)))
                                (then unreachable))
                            (global.set $subtask
                                (i32.shr_u (local.get $status) (i32.const 4)))
                            (call $waitable-join
                                (global.get $subtask)
                                (global.get $set))
                            (i32.or
                                (i32.const 2 (; WAIT ;))
                                (i32.shl (global.get $set) (i32.const 4))))

                        (func (export "callback")
                            (param $event i32) (param $handle i32) (param $result i32)
                            (result i32)
                            (if (i32.ne (local.get $event) (i32.const 1 (; SUBTASK ;)))
                                (then unreachable))
                            (if (i32.ne (local.get $handle) (global.get $subtask))
                                (then unreachable))
                            (if (i32.ne (local.get $result) (i32.const 2 (; RETURNED ;)))
                                (then unreachable))
                            (call $subtask-drop (global.get $subtask))
                            call $finish
                            i32.const 0 (; EXIT ;))

                        (func (export "reenter") (param i32)
                            (call $drop (local.get 0))))
                    (core instance $i (instantiate $m
                        (with "" (instance
                            (export "new" (func $new))
                            (export "borrow" (func $borrow))
                            (export "drop" (func $drop))
                            (export "task-return" (func $task-return))
                            (export "waitable-set-new" (func $waitable-set-new))
                            (export "waitable-set-drop" (func $waitable-set-drop))
                            (export "waitable-join" (func $waitable-join))
                            (export "subtask-drop" (func $subtask-drop))))))
                    (func (export "run") async
                        (canon lift (core func $i "run") async
                            (callback (core func $i "callback"))))
                    (func (export "reenter") (param "r" (borrow $r))
                        (canon lift (core func $i "reenter")))
                )
            "#,
        )?;

        let mut store = Store::new(&engine, State::default());
        let mut linker = Linker::<State>::new(&engine);
        linker
            .root()
            .resource("r", ResourceType::host::<MyType>(), |mut store, _| {
                store.data_mut().dropped = true;
                Ok(())
            })?;
        linker
            .root()
            .func_wrap("new", |_, ()| Ok((Resource::<MyType>::new_own(0),)))?;
        linker.root().func_wrap_concurrent(
            "borrow",
            move |accessor: &Accessor<State>, (r,): (Resource<MyType>,)| {
                let mut resource = Some(r);
                Box::pin(async move {
                    let reenter_func = accessor
                        .with(|mut s| s.get().instance.unwrap().get_func(s, "reenter").unwrap());
                    for a in actions {
                        match a {
                            HostAction::Yield => tokio::task::yield_now().await,
                            HostAction::CallWasm => {
                                let r = resource.take().unwrap();
                                let any_r = accessor.with(|s| r.try_into_resource_any(s))?;
                                let params = [Val::Resource(any_r)];
                                reenter_func
                                    .call_concurrent(accessor, &params, &mut [])
                                    .await?;
                                let [Val::Resource(any_r)] = params else {
                                    panic!("Unexpected param type");
                                };
                                resource =
                                    Some(accessor.with(|s| any_r.try_into_resource::<MyType>(s))?);
                            }
                        }
                    }
                    Ok(())
                })
            },
        )?;

        let instance = linker.instantiate_async(&mut store, &component).await?;
        store.data_mut().instance = Some(instance);
        let run = instance.get_typed_func::<(), ()>(&mut store, "run")?;
        run.call_async(&mut store, ()).await?;
        assert!(store.data().dropped);
        store.assert_concurrent_state_empty();
        Ok(())
    }
}

mod multiple_host_borrows {
    use super::*;

    struct R;

    #[derive(Clone, Copy, Debug)]
    enum Kind {
        Wrap,
        New,
    }

    // `run` creates two borrows and passes several of them to host imports in a
    // single call: two `borrow` params (`two`) and a `list<borrow>` (`list`).
    // Lifting the second `borrow` as a `ResourceAny` used to trip
    // `bail_bug!("deferred host scope has no call context")`. The export is
    // async-lifted so the call runs through the event loop.
    const COMPONENT: &str = r#"
        (component
            (import "r" (type $r (sub resource)))
            (import "mk" (func $mk (result (own $r))))
            (import "two" (func $two async (param "a" (borrow $r)) (param "b" (borrow $r))))
            (import "list" (func $list async (param "a" (list (borrow $r)))))

            (core module $libc (memory (export "memory") 1))
            (core instance $libc (instantiate $libc))

            (core func $mk (canon lower (func $mk)))
            (core func $two (canon lower (func $two)))
            (core func $list (canon lower (func $list) (memory (core memory $libc "memory"))))
            (core func $drop (canon resource.drop $r))

            (core module $m
                (import "" "mk" (func $mk (result i32)))
                (import "" "two" (func $two (param i32 i32)))
                (import "" "list" (func $list (param i32 i32)))
                (import "" "drop" (func $drop (param i32)))
                (import "libc" "memory" (memory 1))

                (func (export "run")
                    (local $a i32)
                    (local $b i32)
                    (local.set $a (call $mk))
                    (local.set $b (call $mk))

                    (call $two (local.get $a) (local.get $b))

                    ;; list<borrow<r>> of length 3 at address 8
                    (i32.store offset=8 (i32.const 0) (local.get $a))
                    (i32.store offset=12 (i32.const 0) (local.get $b))
                    (i32.store offset=16 (i32.const 0) (local.get $a))
                    (call $list (i32.const 8) (i32.const 3))

                    (call $drop (local.get $a))
                    (call $drop (local.get $b))
                )
            )
            (core instance $i (instantiate $m
                (with "" (instance
                    (export "mk" (func $mk))
                    (export "two" (func $two))
                    (export "list" (func $list))
                    (export "drop" (func $drop))
                ))
                (with "libc" (instance $libc))
            ))

            ;; Wrap `run` in an async-lifted export.
            (alias core export $i "run" (core func $inner-run))
            (core func $task-return (canon task.return))
            (core module $w
                (import "" "run" (func $run))
                (import "" "task.return" (func $task-return))
                (func (export "run") (result i32)
                    (call $run)
                    (call $task-return)
                    (i32.const 0)) ;; EXIT
                (func (export "cb") (param i32 i32 i32) (result i32) unreachable)
            )
            (core instance $w (instantiate $w
                (with "" (instance
                    (export "run" (func $inner-run))
                    (export "task.return" (func $task-return))
                ))
            ))
            (func (export "run") async
                (canon lift (core func $w "run") async (callback (core func $w "cb"))))
        )
    "#;

    #[tokio::test]
    async fn wrap() -> Result<()> {
        run(Kind::Wrap).await
    }

    #[tokio::test]
    async fn new() -> Result<()> {
        run(Kind::New).await
    }

    async fn drop_val(store: &wasmtime::component::Accessor<()>, val: &Val) -> Result<()> {
        match val {
            Val::Resource(r) => {
                assert!(!r.owned());
                r.resource_drop_concurrent(store).await
            }
            Val::List(vals) => {
                for v in vals {
                    Box::pin(drop_val(store, v)).await?;
                }
                Ok(())
            }
            _ => panic!("unexpected value {val:?}"),
        }
    }

    async fn run(kind: Kind) -> Result<()> {
        let engine = Engine::default();
        let component = Component::new(&engine, COMPONENT)?;

        let mut linker = Linker::<()>::new(&engine);
        let mut root = linker.root();
        root.resource("r", ResourceType::host::<R>(), |_, _| Ok(()))?;
        root.func_wrap("mk", |_, (): ()| Ok((Resource::<R>::new_own(42),)))?;

        match kind {
            Kind::Wrap => {
                root.func_wrap_concurrent("two", |store, (a, b): (ResourceAny, ResourceAny)| {
                    Box::pin(async move {
                        a.resource_drop_concurrent(store).await?;
                        b.resource_drop_concurrent(store).await?;
                        Ok(())
                    })
                })?;
                root.func_wrap_concurrent("list", |store, (list,): (Vec<ResourceAny>,)| {
                    Box::pin(async move {
                        assert_eq!(list.len(), 3);
                        for r in list {
                            r.resource_drop_concurrent(store).await?;
                        }
                        Ok(())
                    })
                })?;
            }
            Kind::New => {
                for name in ["two", "list"] {
                    root.func_new_concurrent(name, |store, _ty, params, _results| {
                        Box::pin(async move {
                            for p in params {
                                drop_val(store, p).await?;
                            }
                            Ok(())
                        })
                    })?;
                }
            }
        }

        let mut store = Store::new(&engine, ());
        let instance = linker.instantiate_async(&mut store, &component).await?;
        let run = instance.get_typed_func::<(), ()>(&mut store, "run")?;
        run.call_async(&mut store, ()).await?;
        store.assert_concurrent_state_empty();
        Ok(())
    }
}