Function drop_on_owned_resource

tests/all/component_model/resources.rs:1355–1425

()

#[tokio::test]
async fn drop_on_owned_resource() -> Result<()> {
    let mut config = wasmtime::Config::new();
    config.wasm_component_model_async(true);
    let engine = &wasmtime::Engine::new(&config)?;
    let c = Component::new(
        &engine,
        r#"
            (component
                (import "t" (type $t (sub resource)))
                (import "[constructor]t" (func $ctor (result (own $t))))
                (import "[method]t.foo" (func $foo async (param "self" (borrow $t))))

                (core func $ctor (canon lower (func $ctor)))
                (core func $drop (canon resource.drop $t))
                (core func $foo (canon lower (func $foo) async))

                (core module $m
                    (import "" "ctor" (func $ctor (result i32)))
                    (import "" "foo" (func $foo (param i32) (result i32)))
                    (import "" "drop" (func $drop (param i32)))

                    (func (export "f")
                        (local $r i32)
                        (local $status i32)
                        (local.set $r (call $ctor))
                        (local.set $status (call $foo (local.get $r)))
                        (if (i32.ne (i32.const 1 (; STARTED ;)) (i32.and (local.get $status) (i32.const 0xf)))
                           (then unreachable))
                        (call $drop (local.get $r))
                        (unreachable)
                    )
                )
                (core instance $i (instantiate $m
                    (with "" (instance
                        (export "ctor" (func $ctor))
                        (export "foo" (func $foo))
                        (export "drop" (func $drop))
                    ))
                ))
                (func (export "f") async (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("[constructor]t", |_, ()| {
        Ok((Resource::<MyType>::new_own(300),))
    })?;
    linker
        .root()
        .func_wrap_concurrent("[method]t.foo", |_cx, (r,): (Resource<MyType>,)| {
            assert!(!r.owned());