fix: Add tests and fix the regression with clone_userdata

cc gluon-lang#779
cc @Etherian

codegen/src/userdata.rs

@@ -55,10 +55,10 @@ fn gen_impl(container: &Container, ident: Ident, generics: Generics) -> TokenStr
 
     let deep_clone = if container.clone {
         quote! {
-            fn deep_clone(
+            fn deep_clone<'gc>(
                 &self,
-                deep_cloner: &mut _gluon_api::Cloner
-            ) -> _gluon_Result<_gluon_gc::GcPtr<Box<dyn _gluon_api::Userdata>>> {
+                deep_cloner: &'gc mut _gluon_api::Cloner
+            ) -> _gluon_Result<_gluon_gc::GcRef<'gc, Box<dyn _gluon_api::Userdata>>> {
                 let data: Box<dyn _gluon_api::Userdata> = Box::new(self.clone());
                 deep_cloner.gc().alloc(_gluon_gc::Move(data))
             }

examples/marshalling.rs

@@ -334,7 +334,9 @@ fn marshal_wrapper() -> Result<()> {
     Ok(())
 }
 
-#[derive(Userdata, Trace, Debug, Clone, VmType)]
+#[derive(Userdata, Trace, Clone, Debug, VmType)]
+#[gluon_userdata(clone)]
+// Lets gluon know that the value can be cloned which can be needed when transferring the value between threads
 #[gluon(vm_type = "WindowHandle")]
 struct WindowHandle {
     id: Arc<u64>,
@@ -348,6 +350,7 @@ fn load_mod(vm: &gluon::Thread) -> vm::Result<ExternModule> {
         create_hwnd => primitive!(2, create_hwnd),
         id => primitive!(1, id),
         metadata => primitive!(1, metadata),
+        default_hwnd => create_hwnd(0, "default".into()),
     };
 
     ExternModule::new(vm, module)

parser/src/grammar.lalrpop

@@ -806,15 +806,15 @@ Expr: Expr<Id> = {
     },
 
     <metadata: Metadata?> "rec" <bindings: RecursiveValueBinding+> <body: InExpr> => {
-        let mut bindings = bindings.into_iter().map(|x| *x).collect::<Vec<_>>();;
+        let mut bindings = bindings.into_iter().map(|x| *x).collect::<Vec<_>>();
         if let Some(metadata) = metadata {
             bindings[0].metadata = metadata;
         }
         Expr::LetBindings(ValueBindings::Recursive(bindings), Box::new(body))
     },
 
     <metadata: Metadata?> "rec" <bindings: TypeBinding+> <body: InExpr> => {
-        let mut bindings = bindings.into_iter().map(|x| *x).collect::<Vec<_>>();;
+        let mut bindings = bindings.into_iter().map(|x| *x).collect::<Vec<_>>();
         if let Some(metadata) = metadata {
             bindings[0].metadata = metadata;
         }

tests/api.rs

@@ -705,3 +705,28 @@ fn child_vm_do_not_cause_undroppable_cycle_reverse_drop_order() {
         "The virtual machine and its values were not dropped"
     );
 }
+
+#[test]
+fn clone_userdata() {
+    let _ = ::env_logger::try_init();
+
+    let expr = r#"
+        import! test
+    "#;
+
+    #[derive(Debug, Userdata, Trace, VmType, Clone, PartialEq)]
+    #[gluon(vm_type = "Test")]
+    #[gluon_userdata(clone)]
+    struct Test(VmInt);
+
+    let vm = make_vm();
+    vm.register_type::<Test>("Test", &[])
+        .unwrap_or_else(|_| panic!("Could not add type"));
+    add_extern_module(&vm, "test", |thread| ExternModule::new(thread, Test(123)));
+
+    let (result, _) = Compiler::new()
+        .run_expr::<OpaqueValue<RootedThread, Test>>(&vm, "<top>", expr)
+        .unwrap_or_else(|err| panic!("{}", err));
+
+    assert_eq!(*result, Test(123));
+}