Function::new_native support for closures with captured environments

[matthew-a-thomas]

Describe the bug

Function::new_native seems to be playing fast and loose with closures.

Cargo.toml:

[dependencies]
anyhow = "1.0.34"
wasmer = "1.0.0-alpha5"
wasmer-compiler-cranelift = "1.0.0-alpha5"
wasmer-engine-jit = "1.0.0-alpha5"

For reference this (correctly) prints "42":

use anyhow::Result;
use wasmer::*;

fn main() -> Result<()> {
    let wat = r#"(module
        (import "console" "log" (func $log (param i32)))
        (func (export "main")
          i32.const 42
          call $log
        )
    )"#;
    let cranelift = Cranelift::default();
    let store = Store::new(&JIT::new(&cranelift).engine());
    let module = Module::new(&store, wat)?;
    let import_object = imports! {
        "console" => {
            "log" => Function::new_native(&store, |value: i32| {
                println!("{}", value);
            })
        }
    };
    let instance = Instance::new(&module, &import_object)?;
    let main: NativeFunc<(), ()> = instance
        .exports
        .get_native_function("main")?;
    main.call()?;
    Ok(())
}

This (incorrectly) crashes the program with a stack overflow:

use anyhow::Result;
use wasmer::*;
use std::sync::Arc;

fn main() -> Result<()> {
    let wat = r#"(module
        (import "console" "log" (func $log (param i32)))
        (func (export "main")
          i32.const 42
          call $log
        )
    )"#;
    let cranelift = Cranelift::default();
    let store = Store::new(&JIT::new(&cranelift).engine());
    let module = Module::new(&store, wat)?;
    let message = "message";
    let message_arc = Arc::new(message);
    let import_object = imports! {
        "console" => {
            "log" => Function::new_native(&store, move |value: i32| {
                println!("{}, {}", message_arc, value);
            })
        }
    };
    let instance = Instance::new(&module, &import_object)?;
    let main: NativeFunc<(), ()> = instance
        .exports
        .get_native_function("main")?;
    main.call()?;
    Ok(())
}

This (incorrectly) prints 0:

use anyhow::Result;
use wasmer::*;

fn main() -> Result<()> {
    let wat = r#"(module
        (import "console" "log" (func $log (param i32)))
        (func (export "main")
          i32.const 42
          call $log
        )
    )"#;
    let cranelift = Cranelift::default();
    let store = Store::new(&JIT::new(&cranelift).engine());
    let module = Module::new(&store, wat)?;
    let state = 1337;
    let import_object = imports! {
        "console" => {
            "log" => Function::new_native(&store, move |_: i32| {
                println!("{}", state);
            })
        }
    };
    let instance = Instance::new(&module, &import_object)?;
    let main: NativeFunc<(), ()> = instance
        .exports
        .get_native_function("main")?;
    main.call()?;
    Ok(())
}

Additional context

Globally-installed things:

wasmer 1.0.0-alpha4
rustc 1.47.0 (18bf6b4f0 2020-10-07)
Windows 10 10.0.19042 N/A Build 19042

[syrusakbary]

Thanks for creating the issue!

Wasmer currently doesn't support closures in Functions, but we have been investigating in the last days to see if we can add support for them. We'll post here our findings!

[syrusakbary]

Even though we merged the PR that panics if closures with captured environments are used for native functions, I'd like to keep this issue open until we fully support closures with captured environments in native functions

[webmaster128]

I'd like to keep this issue open until we fully support closures with captured environments in native functions

Wasn't #1840 supposed to track that? What's the difference between the two tickets?

[Hywan]

Closing in favor of #1840. I had to pick one :-).