Wasmer 3 upgrade: Testing import implementations but FunctionEnvMut is gone

[webmaster128]

Summary

I'm in the process of upgrading to Wasmer 3 but the new FunctionEnv design is causing some trouble.

Additional details

I would like to test my import implementation do_db_read, which is added like this:

        env_imports.insert(
            "db_read",
            Function::new_typed_with_env(&mut store, &fe, do_db_read),
        );

The signature is:

pub fn do_db_read<A: BackendApi + 'static, S: Storage + 'static, Q: Querier + 'static>(
    mut env: FunctionEnvMut<Environment<A, S, Q>>,
    key_ptr: u32,
) -> VmResult<u32> {

I have this test (slightly simplified version):

    #[test]
    fn do_db_read_works() {
        // returns an owned fe: FunctionEnv and store: Strore
        let (fe, mut store, _instance) = make_instance();
        let mut fe_mut = fe.into_mut(&mut store);

        // Populate env with some data before the test
        leave_default_data(&mut fe_mut);
        let key_ptr = write_data(&mut fe_mut, KEY1);

        // The actual test consumed the fe_mut: FunctionEnvMut
        let result = do_db_read(fe_mut, key_ptr);

        // Aftermath has no function env available anymore 😢
        let value_ptr = result.unwrap();
        assert!(value_ptr > 0);
        assert_eq!(force_read(fe.into_mut(&mut store), value_ptr), VALUE1);
    }

I do understand that FunctionEnv and FunctionEnvMut are not supposed to be clonable. And my import implementation must take an owned FunctionEnvMut. Also FunctionEnv -> FunctionEnvMut always consumes the env. How do I access my env after the call to the import implementation?

[ptitSeb]

Use data() or data_mut() or data_and_store_mut() from a FunctionEnvMut to access your env.

[webmaster128]

I use those internally in leave_default_data/write_data/do_db_read/force_read.

But after the call to do_db_read(fe_mut, key_ptr) the fe_mut is gone and I can't use those functions anymore.

[ptitSeb]

can't you use something like do_db_read(fe_mut.as_mut(), key_ptr) to avoid consuming fe_mut?

[webmaster128]

The issue is that Function::new_typed_with_env( forces me to consume the FunctionEnvMut. Ideally I'd change

  pub fn do_db_read<A: BackendApi + 'static, S: Storage + 'static, Q: Querier + 'static>(
-     mut env: FunctionEnvMut<Environment<A, S, Q>>,
+     mut env: &mut FunctionEnvMut<Environment<A, S, Q>>,
      key_ptr: u32,
  ) -> VmResult<u32> {

but new_typed_with_env does not like that version.

[ptitSeb]

But again, as_mut() should act like a clone() and allow you to duplicated FunctionEnvMut

[webmaster128]

Oh, yeah, indeed it does. Then is what I missed. Looks good at first glance! Will test further and report back. Thanks a lot!

[webmaster128]

FunctionEnvMut::as_mut was the solution I looked for and missed between all the options

[ptitSeb]

Also, converting this to a discussion.

[webmaster128]

One solution seems to be downgrading the owned FunctionEnvMut to a reference in a wrapper function like this:

        fn do_db_read_wrapper<
            A: BackendApi + 'static,
            S: Storage + 'static,
            Q: Querier + 'static,
        >(
            mut ctx: FunctionEnvMut<Environment<A, S, Q>>,
            a: u32,
        ) -> VmResult<u32> {
            do_db_read(&mut ctx, a)
        }
        env_imports.insert(
            "db_read",
            Function::new_typed_with_env(&mut store, &fe, do_db_read_wrapper),
        );

But this is a lot of overhead for all the functions.

I tried using closures to but it seems like closures are not possible in new_typed_with_env. Is this correct?