Test setting signal handler and a few fix to make it work

We were not parsing CodeBlock node from the signal handler correctly,
we wer eonly taking the first expression instead of the whole codeblock

In JS, emitting signal before the show() did not update the GLOBAL_CONTEXT
needed to emit signals defined in JS

api/sixtyfps-cpp/include/sixtyfps_signals.h

@@ -21,7 +21,7 @@ struct Signal
                 [](void *user_data) {
                     (*reinterpret_cast<F *>(user_data))();
                 },
-                new F(binding), [](void *user_data) { delete reinterpret_cast<F *>(user_data); });
+                new F(std::move(binding)), [](void *user_data) { delete reinterpret_cast<F *>(user_data); });
     }
 
     void emit() const

api/sixtyfps-node/native/lib.rs

@@ -287,10 +287,18 @@ declare_types! {
             let lock = cx.lock();
             let x = this.borrow(&lock).0.clone();
             let component = x.ok_or(()).or_else(|()| cx.throw_error("Invalid type"))?;
+            let persistent_context = persistent_context::PersistentContext::from_object(&mut cx, this.downcast().unwrap())?;
+
+            cx.execute_scoped(|cx| {
+                let cx = RefCell::new(cx);
+                let cx_fn = move |callback: &GlobalContextCallback| {
+                    callback(&mut *cx.borrow_mut(), &persistent_context)
+                };
+                GLOBAL_CONTEXT.set(&&cx_fn, || {
                     component.description()
                         .emit_signal(component.borrow(), signal_name.as_str())
-                .or_else(|_| cx.throw_error(format!("Cannot emit signal")))?;
-
+                })
+            }).or_else(|_| cx.throw_error(format!("Cannot emit signal")))?;
             Ok(JsUndefined::new().as_value(&mut cx))
         }
     }

sixtyfps_compiler/passes/resolving.rs

@@ -73,9 +73,7 @@ fn resolve_expression(
         let new_expr = match node.kind() {
             SyntaxKind::CodeBlock => {
                 //FIXME: proper signal suport (node is a codeblock)
-                node.child_node(SyntaxKind::Expression)
-                    .map(|en| Expression::from_expression_node(en.into(), &mut lookup_ctx))
-                    .unwrap_or(Expression::Invalid)
+                Expression::from_codeblock_node(node.clone(), &mut lookup_ctx)
             }
             SyntaxKind::Expression => {
                 //FIXME again: this happen for non-binding expression (i.e: model)

tests/cases/signal_handler.60

@@ -1,40 +1,54 @@
 TestCase := Rectangle {
     signal test_signal;
     signal test_signal2;
+    signal test_signal3;
     property<int32> signal_emission_count;
     test_signal => { signal_emission_count += 1; }
-    test_signal2 => { signal_emission_count = 88; }
+    test_signal2 => {  signal_emission_count = 88; root.test_signal3(); }
 }
 /*
 ```cpp
 TestCase instance;
+int signal_3_emited = 0;
+instance.on_test_signal3([&]{ signal_3_emited++; });
 instance.set_signal_emission_count(0);
 assert(instance.get_signal_emission_count() == 0);
 instance.emit_test_signal();
 assert(instance.get_signal_emission_count() == 1);
 instance.emit_test_signal();
 assert(instance.get_signal_emission_count() == 2);
+assert(signal_3_emited == 0);
 instance.emit_test_signal2();
 assert(instance.get_signal_emission_count() == 88);
-
+assert(signal_3_emited == 1);
 ```
 
 
 ```rust
 let instance = TestCase::new();
 let instance = instance.as_ref();
+let signal_3_emited = std::rc::Rc::new(std::cell::Cell::new(0));
+instance.on_test_signal3({
+    let signal_3_emited = signal_3_emited.clone();
+    move || signal_3_emited.set(signal_3_emited.get() + 1)
+});
 instance.set_signal_emission_count(0);
 assert_eq!(instance.get_signal_emission_count(), 0);
 instance.emit_test_signal();
 assert_eq!(instance.get_signal_emission_count(), 1);
 instance.emit_test_signal();
 assert_eq!(instance.get_signal_emission_count(), 2);
+assert_eq!(signal_3_emited.get(), 0);
 instance.emit_test_signal2();
 assert_eq!(instance.get_signal_emission_count(), 88);
+assert_eq!(signal_3_emited.get(), 1);
 ```
 
 ```js
-var instance = new sixtyfps.TestCase({});
+var signal_3_emited = 0;
+var instance = new sixtyfps.TestCase({
+    test_signal3: function() { signal_3_emited++; }
+});
 instance.signal_emission_count = 0;
 assert.equal(instance.signal_emission_count, 0);
 instance.test_signal();
@@ -43,7 +57,9 @@ let x = instance.test_signal;
 assert.equal(instance.signal_emission_count, 1);
 x()
 assert.equal(instance.signal_emission_count, 2);
+assert.equal(signal_3_emited, 0);
 instance.test_signal2();
 assert.equal(instance.signal_emission_count, 88);
+assert.equal(signal_3_emited, 1);
 ```
 */