Userdata does not implement Getable

userdata_not_getable.rs

#[macro_use]
extern crate gluon_codegen;
extern crate gluon;
#[macro_use]
extern crate gluon_vm;

use std::sync::Arc;
use gluon::vm::{self, ExternModule};

use gluon::{import::Import, RootedThread};

pub fn new_vm() -> RootedThread {
    if ::std::env::var("GLUON_PATH").is_err() {
        ::std::env::set_var("GLUON_PATH", "..");
    }

    let vm = gluon::new_vm();
    let import = vm.get_macros().get("import");
    import
        .as_ref()
        .and_then(|import| import.downcast_ref::<Import>())
        .expect("Import macro")
        .add_path("..");

    vm
}

#[derive(Userdata, Debug)]
struct WindowHandle {
    id: Arc<u64>,
    metadata: Arc<str>,
}

fn load_mod(vm: &gluon::Thread) -> vm::Result<ExternModule> {
    vm.register_type::<WindowHandle>("WindowHandle", &[])?;

    let module = record! {
        create_hwnd => primitive!(2 create_hwnd),
        id => primitive!(1 id),
        metadata => primitive!(1 metadata),
    };

    ExternModule::new(vm, module)
}

fn create_hwnd(id: u64, metadata: String) -> WindowHandle {
    WindowHandle {
        id: Arc::new(id),
        metadata: Arc::from(metadata),
    }
}

fn id(hwnd: &WindowHandle) -> u64 {
    *hwnd.id
}

fn metadata(hwnd: &WindowHandle) -> String {
    String::from(&*hwnd.metadata)
}

fn main() {
    let vm = new_vm();
    let mut compiler = gluon::Compiler::new();

    gluon::import::add_extern_module(&vm, "hwnd", load_mod);

    let script = r#"
        let { assert } = import! std.test
        let { create_hwnd, id, metadata } = import! hwnd

        let hwnd = create_hwnd 0 "Window1"
        assert (id hwnd == 0)
        assert (metadata hwnd == "Window1")
        hwnd
    "#;

    if let Err(why) = compiler.run_expr::<WindowHandle>(&vm, "test", script) {
        panic!("{}", why);
    }
}