Resource::new_borrow() resource -> ResourceAny conversion panics

[rvolosatovs]

Test Case

#[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))
                    )
                )
                (core instance $i (instantiate $m
                    (with "" (instance
                        (export "drop" (func $drop))
                    ))
                ))

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

    struct MyType;

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

Steps to Reproduce

(see test case)

Expected Results

Success, just like with lowering of Resource directly

Actual Results

Panic in

wasmtime/crates/runtime/src/component/resources.rs

Line 241 in f3b5478

let scope = self.calls.scopes.len() - 1;

Versions and Environment

Wasmtime version or commit: f3b5478

Extra Info

The panic makes sense, since there is no "owned" version of this resource in any table, only a "synthetic" borrow.

I believe the panic is caused by

wasmtime/crates/wasmtime/src/component/resources.rs

Line 568 in f3b5478

BORROW => (tables.resource_lower_borrow(None, rep), None),

, note that in case of Resource, the analogous operation simply returns the rep

wasmtime/crates/wasmtime/src/component/resources.rs

Line 334 in f3b5478

BORROW => self.rep,

Refs #7688 #7783

[alexcrichton]

Ah yes I see where this is coming from and it's a bit unfortunate. Borrows have metadata tracking them to ensure that they're all dropped by the time a function call exits. For example if 4 borrows are given to an exported function then all borrows must be dropped by the exported function before the function returns, otherwise the component model requires a trap.

I think that the implementation here is going to have to be a bit more "clever" like the bits in Resource<T> where the lowering into a borrow is actually deferred until the lift/lower operation happens. Basically resource_lower_borrow can't be called until a function is being invoked.