codegen: Fix usage of lambda-expression from delegate initializer

Unset delegate-type if a lambda-expression handler was found to use
the correct code paths.

Fixes https://gitlab.gnome.org/GNOME/vala/issues/1428

4 files changed, 1290 insertions, 0 deletions

diff --git a/codegen/valagsignalmodule.vala b/codegen/valagsignalmodule.vala
index 7f02b17f1..11389bade 100644
--- a/codegen/valagsignalmodule.vala
+++ b/codegen/valagsignalmodule.vala
@@ -605,6 +605,7 @@ public class Vala.GSignalModule : GObjectModule {
 			// Use actual lambda expression if available for proper target/destroy handling
 			if (((Variable) handler.symbol_reference).initializer is LambdaExpression) {
 				handler = ((Variable) handler.symbol_reference).initializer;
+				dt = null;
 			}
 		}
 		var m = handler.symbol_reference as Method;
diff --git a/tests/Makefile.am b/tests/Makefile.am
index b7a46cb31..99cee6206 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -613,6 +613,7 @@ TESTS = \
 	objects/signals-generic-return.vala \
 	objects/signals-gobject-return.vala \
 	objects/signals-lambda-delegate.vala \
+	objects/signals-lambda-delegate-2.vala \
 	objects/signals-prototype-access.vala \
 	objects/signals-prototype-access-invalid.test \
 	objects/signals-prototype-access-invalid-2.test \
diff --git a/tests/objects/signals-lambda-delegate-2.c-expected b/tests/objects/signals-lambda-delegate-2.c-expected
new file mode 100644
index 000000000..b9706f399
--- /dev/null
+++ b/tests/objects/signals-lambda-delegate-2.c-expected
@@ -0,0 +1,1194 @@
+/* objects_signals_lambda_delegate_2.c generated by valac, the Vala compiler
+ * generated from objects_signals_lambda_delegate_2.vala, do not modify */
+
+#include <stdlib.h>
+#include <string.h>
+#include <glib.h>
+#include <glib-object.h>
+#include <gobject/gvaluecollector.h>
+
+#if !defined(VALA_EXTERN)
+#if defined(_WIN32) || defined(__CYGWIN__)
+#define VALA_EXTERN __declspec(dllexport) extern
+#elif __GNUC__ >= 4
+#define VALA_EXTERN __attribute__((visibility("default"))) extern
+#else
+#define VALA_EXTERN extern
+#endif
+#endif
+
+#define TYPE_FOO (foo_get_type ())
+#define FOO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_FOO, Foo))
+#define FOO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_FOO, FooClass))
+#define IS_FOO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_FOO))
+#define IS_FOO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_FOO))
+#define FOO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_FOO, FooClass))
+
+typedef struct _Foo Foo;
+typedef struct _FooClass FooClass;
+typedef gchar* (*FooFunc) (Foo* foo, const gchar* s, gpointer user_data);
+typedef struct _FooPrivate FooPrivate;
+enum  {
+	FOO_0_PROPERTY,
+	FOO_NUM_PROPERTIES
+};
+static GParamSpec* foo_properties[FOO_NUM_PROPERTIES];
+enum  {
+	FOO_TEST_SIGNAL,
+	FOO_NUM_SIGNALS
+};
+static guint foo_signals[FOO_NUM_SIGNALS] = {0};
+
+#define TYPE_BAR (bar_get_type ())
+#define BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_BAR, Bar))
+#define BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_BAR, BarClass))
+#define IS_BAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_BAR))
+#define IS_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_BAR))
+#define BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_BAR, BarClass))
+
+typedef struct _Bar Bar;
+typedef struct _BarClass BarClass;
+typedef struct _BarPrivate BarPrivate;
+enum  {
+	BAR_0_PROPERTY,
+	BAR_NUM_PROPERTIES
+};
+static GParamSpec* bar_properties[BAR_NUM_PROPERTIES];
+#define _g_free0(var) (var = (g_free (var), NULL))
+#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
+
+#define TYPE_FAZ (faz_get_type ())
+#define FAZ(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_FAZ, Faz))
+#define FAZ_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_FAZ, FazClass))
+#define IS_FAZ(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_FAZ))
+#define IS_FAZ_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_FAZ))
+#define FAZ_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_FAZ, FazClass))
+
+typedef struct _Faz Faz;
+typedef struct _FazClass FazClass;
+typedef gchar* (*FazFunc) (Faz* faz, const gchar* s, gpointer user_data);
+typedef struct _FazPrivate FazPrivate;
+typedef struct _ParamSpecFaz ParamSpecFaz;
+enum  {
+	FAZ_TEST_SIGNAL,
+	FAZ_NUM_SIGNALS
+};
+static guint faz_signals[FAZ_NUM_SIGNALS] = {0};
+
+#define TYPE_BOO (boo_get_type ())
+#define BOO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_BOO, Boo))
+#define BOO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_BOO, BooClass))
+#define IS_BOO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_BOO))
+#define IS_BOO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_BOO))
+#define BOO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_BOO, BooClass))
+
+typedef struct _Boo Boo;
+typedef struct _BooClass BooClass;
+typedef struct _BooPrivate BooPrivate;
+#define _faz_unref0(var) ((var == NULL) ? NULL : (var = (faz_unref (var), NULL)))
+typedef struct _ParamSpecBoo ParamSpecBoo;
+#define _boo_unref0(var) ((var == NULL) ? NULL : (var = (boo_unref (var), NULL)))
+#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
+#define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; }
+#define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; }
+#define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg);
+
+struct _Foo {
+	GObject parent_instance;
+	FooPrivate * priv;
+};
+
+struct _FooClass {
+	GObjectClass parent_class;
+};
+
+struct _Bar {
+	GObject parent_instance;
+	BarPrivate * priv;
+};
+
+struct _BarClass {
+	GObjectClass parent_class;
+};
+
+struct _Faz {
+	GTypeInstance parent_instance;
+	volatile int ref_count;
+	FazPrivate * priv;
+};
+
+struct _FazClass {
+	GTypeClass parent_class;
+	void (*finalize) (Faz *self);
+};
+
+struct _ParamSpecFaz {
+	GParamSpec parent_instance;
+};
+
+struct _Boo {
+	GTypeInstance parent_instance;
+	volatile int ref_count;
+	BooPrivate * priv;
+};
+
+struct _BooClass {
+	GTypeClass parent_class;
+	void (*finalize) (Boo *self);
+};
+
+struct _ParamSpecBoo {
+	GParamSpec parent_instance;
+};
+
+static gpointer foo_parent_class = NULL;
+static gpointer bar_parent_class = NULL;
+static gpointer faz_parent_class = NULL;
+static gpointer boo_parent_class = NULL;
+
+VALA_EXTERN GType foo_get_type (void) G_GNUC_CONST ;
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (Foo, g_object_unref)
+VALA_EXTERN Foo* foo_new (void);
+VALA_EXTERN Foo* foo_construct (GType object_type);
+static void g_cclosure_user_marshal_STRING__STRING (GClosure * closure,
+                                             GValue * return_value,
+                                             guint n_param_values,
+                                             const GValue * param_values,
+                                             gpointer invocation_hint,
+                                             gpointer marshal_data);
+static GType foo_get_type_once (void);
+VALA_EXTERN GType bar_get_type (void) G_GNUC_CONST ;
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (Bar, g_object_unref)
+VALA_EXTERN void bar_run (Bar* self);
+static gchar* _vala_lambda0_ (Bar* self,
+                       Foo* f,
+                       const gchar* s);
+static gchar* __vala_lambda0__foo_func (Foo* foo,
+                                 const gchar* s,
+                                 gpointer self);
+VALA_EXTERN Bar* bar_new (void);
+VALA_EXTERN Bar* bar_construct (GType object_type);
+static GObject * bar_constructor (GType type,
+                           guint n_construct_properties,
+                           GObjectConstructParam * construct_properties);
+static gchar* _vala_lambda1_ (Bar* self,
+                       Foo* f,
+                       const gchar* s);
+static gchar* __vala_lambda1__foo_func (Foo* foo,
+                                 const gchar* s,
+                                 gpointer self);
+static GType bar_get_type_once (void);
+VALA_EXTERN gpointer faz_ref (gpointer instance);
+VALA_EXTERN void faz_unref (gpointer instance);
+VALA_EXTERN GParamSpec* param_spec_faz (const gchar* name,
+                            const gchar* nick,
+                            const gchar* blurb,
+                            GType object_type,
+                            GParamFlags flags);
+VALA_EXTERN void value_set_faz (GValue* value,
+                    gpointer v_object);
+VALA_EXTERN void value_take_faz (GValue* value,
+                     gpointer v_object);
+VALA_EXTERN gpointer value_get_faz (const GValue* value);
+VALA_EXTERN GType faz_get_type (void) G_GNUC_CONST ;
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (Faz, faz_unref)
+VALA_EXTERN Faz* faz_new (void);
+VALA_EXTERN Faz* faz_construct (GType object_type);
+static void faz_finalize (Faz * obj);
+static GType faz_get_type_once (void);
+VALA_EXTERN gpointer boo_ref (gpointer instance);
+VALA_EXTERN void boo_unref (gpointer instance);
+VALA_EXTERN GParamSpec* param_spec_boo (const gchar* name,
+                            const gchar* nick,
+                            const gchar* blurb,
+                            GType object_type,
+                            GParamFlags flags);
+VALA_EXTERN void value_set_boo (GValue* value,
+                    gpointer v_object);
+VALA_EXTERN void value_take_boo (GValue* value,
+                     gpointer v_object);
+VALA_EXTERN gpointer value_get_boo (const GValue* value);
+VALA_EXTERN GType boo_get_type (void) G_GNUC_CONST ;
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (Boo, boo_unref)
+VALA_EXTERN Boo* boo_new (void);
+VALA_EXTERN Boo* boo_construct (GType object_type);
+static gchar* _vala_lambda2_ (Boo* self,
+                       Faz* f,
+                       const gchar* s);
+static gchar* __vala_lambda2__faz_func (Faz* faz,
+                                 const gchar* s,
+                                 gpointer self);
+VALA_EXTERN void boo_run (Boo* self);
+static gchar* _vala_lambda3_ (Boo* self,
+                       Faz* f,
+                       const gchar* s);
+static gchar* __vala_lambda3__faz_func (Faz* faz,
+                                 const gchar* s,
+                                 gpointer self);
+static void boo_finalize (Boo * obj);
+static GType boo_get_type_once (void);
+static void _vala_main (void);
+static gchar* _vala_lambda4_ (Foo* f,
+                       const gchar* s);
+static gchar* __vala_lambda4__foo_func (Foo* foo,
+                                 const gchar* s,
+                                 gpointer self);
+static gchar* _vala_lambda5_ (Faz* f,
+                       const gchar* s);
+static gchar* __vala_lambda5__faz_func (Faz* faz,
+                                 const gchar* s,
+                                 gpointer self);
+
+Foo*
+foo_construct (GType object_type)
+{
+	Foo * self = NULL;
+	self = (Foo*) g_object_new (object_type, NULL);
+	return self;
+}
+
+Foo*
+foo_new (void)
+{
+	return foo_construct (TYPE_FOO);
+}
+
+static void
+g_cclosure_user_marshal_STRING__STRING (GClosure * closure,
+                                        GValue * return_value,
+                                        guint n_param_values,
+                                        const GValue * param_values,
+                                        gpointer invocation_hint,
+                                        gpointer marshal_data)
+{
+	typedef const char* (*GMarshalFunc_STRING__STRING) (gpointer data1, const char* arg_1, gpointer data2);
+	register GMarshalFunc_STRING__STRING callback;
+	register GCClosure * cc;
+	register gpointer data1;
+	register gpointer data2;
+	const char* v_return;
+	cc = (GCClosure *) closure;
+	g_return_if_fail (return_value != NULL);
+	g_return_if_fail (n_param_values == 2);
+	if (G_CCLOSURE_SWAP_DATA (closure)) {
+		data1 = closure->data;
+		data2 = param_values->data[0].v_pointer;
+	} else {
+		data1 = param_values->data[0].v_pointer;
+		data2 = closure->data;
+	}
+	callback = (GMarshalFunc_STRING__STRING) (marshal_data ? marshal_data : cc->callback);
+	v_return = callback (data1, g_value_get_string (param_values + 1), data2);
+	g_value_take_string (return_value, v_return);
+}
+
+static void
+foo_class_init (FooClass * klass,
+                gpointer klass_data)
+{
+	foo_parent_class = g_type_class_peek_parent (klass);
+	foo_signals[FOO_TEST_SIGNAL] = g_signal_new ("test", TYPE_FOO, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_STRING__STRING, G_TYPE_STRING, 1, G_TYPE_STRING);
+}
+
+static void
+foo_instance_init (Foo * self,
+                   gpointer klass)
+{
+}
+
+static GType
+foo_get_type_once (void)
+{
+	static const GTypeInfo g_define_type_info = { sizeof (FooClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) foo_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Foo), 0, (GInstanceInitFunc) foo_instance_init, NULL };
+	GType foo_type_id;
+	foo_type_id = g_type_register_static (G_TYPE_OBJECT, "Foo", &g_define_type_info, 0);
+	return foo_type_id;
+}
+
+GType
+foo_get_type (void)
+{
+	static volatile gsize foo_type_id__once = 0;
+	if (g_once_init_enter (&foo_type_id__once)) {
+		GType foo_type_id;
+		foo_type_id = foo_get_type_once ();
+		g_once_init_leave (&foo_type_id__once, foo_type_id);
+	}
+	return foo_type_id__once;
+}
+
+static gchar*
+_vala_lambda0_ (Bar* self,
+                Foo* f,
+                const gchar* s)
+{
+	gchar* _tmp0_;
+	gchar* result;
+	g_return_val_if_fail (IS_FOO (f), NULL);
+	g_return_val_if_fail (s != NULL, NULL);
+	_vala_assert (g_strcmp0 (s, "foo") == 0, "s == \"foo\"");
+	_tmp0_ = g_strdup (s);
+	result = _tmp0_;
+	return result;
+}
+
+static gchar*
+__vala_lambda0__foo_func (Foo* foo,
+                          const gchar* s,
+                          gpointer self)
+{
+	gchar* result;
+	result = _vala_lambda0_ ((Bar*) self, foo, s);
+	return result;
+}
+
+void
+bar_run (Bar* self)
+{
+	Foo* foo = NULL;
+	Foo* _tmp0_;
+	FooFunc func = NULL;
+	gpointer func_target;
+	GDestroyNotify func_target_destroy_notify;
+	gchar* _tmp1_ = NULL;
+	gchar* _tmp2_;
+	guint _tmp3_;
+	gchar* _tmp4_ = NULL;
+	gchar* _tmp5_;
+	g_return_if_fail (IS_BAR (self));
+	_tmp0_ = foo_new ();
+	foo = _tmp0_;
+	func = __vala_lambda0__foo_func;
+	func_target = g_object_ref (self);
+	func_target_destroy_notify = g_object_unref;
+	g_signal_connect_object (foo, "test", (GCallback) __vala_lambda0__foo_func, self, 0);
+	g_signal_emit (foo, foo_signals[FOO_TEST_SIGNAL], 0, "foo", &_tmp1_);
+	_tmp2_ = _tmp1_;
+	_vala_assert (g_strcmp0 (_tmp2_, "foo") == 0, "foo.test (\"foo\") == \"foo\"");
+	_g_free0 (_tmp2_);
+	g_signal_parse_name ("test", TYPE_FOO, &_tmp3_, NULL, FALSE);
+	g_signal_handlers_disconnect_matched (foo, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp3_, 0, NULL, (GCallback) __vala_lambda0__foo_func, self);
+	g_signal_emit (foo, foo_signals[FOO_TEST_SIGNAL], 0, "bar", &_tmp4_);
+	_tmp5_ = _tmp4_;
+	_g_free0 (_tmp5_);
+	(func_target_destroy_notify == NULL) ? NULL : (func_target_destroy_notify (func_target), NULL);
+	func = NULL;
+	func_target = NULL;
+	func_target_destroy_notify = NULL;
+	_g_object_unref0 (foo);
+}
+
+Bar*
+bar_construct (GType object_type)
+{
+	Bar * self = NULL;
+	self = (Bar*) g_object_new (object_type, NULL);
+	return self;
+}
+
+Bar*
+bar_new (void)
+{
+	return bar_construct (TYPE_BAR);
+}
+
+static gchar*
+_vala_lambda1_ (Bar* self,
+                Foo* f,
+                const gchar* s)
+{
+	gchar* _tmp0_;
+	gchar* result;
+	g_return_val_if_fail (IS_FOO (f), NULL);
+	g_return_val_if_fail (s != NULL, NULL);
+	_vala_assert (g_strcmp0 (s, "foo") == 0, "s == \"foo\"");
+	_tmp0_ = g_strdup (s);
+	result = _tmp0_;
+	return result;
+}
+
+static gchar*
+__vala_lambda1__foo_func (Foo* foo,
+                          const gchar* s,
+                          gpointer self)
+{
+	gchar* result;
+	result = _vala_lambda1_ ((Bar*) self, foo, s);
+	return result;
+}
+
+static GObject *
+bar_constructor (GType type,
+                 guint n_construct_properties,
+                 GObjectConstructParam * construct_properties)
+{
+	GObject * obj;
+	GObjectClass * parent_class;
+	Bar * self;
+	Foo* foo = NULL;
+	Foo* _tmp0_;
+	FooFunc func = NULL;
+	gpointer func_target;
+	GDestroyNotify func_target_destroy_notify;
+	Foo* _tmp1_;
+	FooFunc _tmp2_;
+	gpointer _tmp2__target;
+	Foo* _tmp3_;
+	gchar* _tmp4_ = NULL;
+	gchar* _tmp5_;
+	Foo* _tmp6_;
+	FooFunc _tmp7_;
+	gpointer _tmp7__target;
+	guint _tmp8_;
+	Foo* _tmp9_;
+	gchar* _tmp10_ = NULL;
+	gchar* _tmp11_;
+	parent_class = G_OBJECT_CLASS (bar_parent_class);
+	obj = parent_class->constructor (type, n_construct_properties, construct_properties);
+	self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_BAR, Bar);
+	_tmp0_ = foo_new ();
+	foo = _tmp0_;
+	func = __vala_lambda1__foo_func;
+	func_target = g_object_ref (self);
+	func_target_destroy_notify = g_object_unref;
+	_tmp1_ = foo;
+	_tmp2_ = func;
+	_tmp2__target = func_target;
+	g_signal_connect_object (_tmp1_, "test", (GCallback) __vala_lambda1__foo_func, self, 0);
+	_tmp3_ = foo;
+	g_signal_emit (_tmp3_, foo_signals[FOO_TEST_SIGNAL], 0, "foo", &_tmp4_);
+	_tmp5_ = _tmp4_;
+	_vala_assert (g_strcmp0 (_tmp5_, "foo") == 0, "foo.test (\"foo\") == \"foo\"");
+	_g_free0 (_tmp5_);
+	_tmp6_ = foo;
+	_tmp7_ = func;
+	_tmp7__target = func_target;
+	g_signal_parse_name ("test", TYPE_FOO, &_tmp8_, NULL, FALSE);
+	g_signal_handlers_disconnect_matched (_tmp6_, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp8_, 0, NULL, (GCallback) __vala_lambda1__foo_func, self);
+	_tmp9_ = foo;
+	g_signal_emit (_tmp9_, foo_signals[FOO_TEST_SIGNAL], 0, "bar", &_tmp10_);
+	_tmp11_ = _tmp10_;
+	_g_free0 (_tmp11_);
+	(func_target_destroy_notify == NULL) ? NULL : (func_target_destroy_notify (func_target), NULL);
+	func = NULL;
+	func_target = NULL;
+	func_target_destroy_notify = NULL;
+	_g_object_unref0 (foo);
+	return obj;
+}
+
+static void
+bar_class_init (BarClass * klass,
+                gpointer klass_data)
+{
+	bar_parent_class = g_type_class_peek_parent (klass);
+	G_OBJECT_CLASS (klass)->constructor = bar_constructor;
+}
+
+static void
+bar_instance_init (Bar * self,
+                   gpointer klass)
+{
+}
+
+static GType
+bar_get_type_once (void)
+{
+	static const GTypeInfo g_define_type_info = { sizeof (BarClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) bar_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Bar), 0, (GInstanceInitFunc) bar_instance_init, NULL };
+	GType bar_type_id;
+	bar_type_id = g_type_register_static (G_TYPE_OBJECT, "Bar", &g_define_type_info, 0);
+	return bar_type_id;
+}
+
+GType
+bar_get_type (void)
+{
+	static volatile gsize bar_type_id__once = 0;
+	if (g_once_init_enter (&bar_type_id__once)) {
+		GType bar_type_id;
+		bar_type_id = bar_get_type_once ();
+		g_once_init_leave (&bar_type_id__once, bar_type_id);
+	}
+	return bar_type_id__once;
+}
+
+Faz*
+faz_construct (GType object_type)
+{
+	Faz* self = NULL;
+	self = (Faz*) g_type_create_instance (object_type);
+	return self;
+}
+
+Faz*
+faz_new (void)
+{
+	return faz_construct (TYPE_FAZ);
+}
+
+static void
+value_faz_init (GValue* value)
+{
+	value->data[0].v_pointer = NULL;
+}
+
+static void
+value_faz_free_value (GValue* value)
+{
+	if (value->data[0].v_pointer) {
+		faz_unref (value->data[0].v_pointer);
+	}
+}
+
+static void
+value_faz_copy_value (const GValue* src_value,
+                      GValue* dest_value)
+{
+	if (src_value->data[0].v_pointer) {
+		dest_value->data[0].v_pointer = faz_ref (src_value->data[0].v_pointer);
+	} else {
+		dest_value->data[0].v_pointer = NULL;
+	}
+}
+
+static gpointer
+value_faz_peek_pointer (const GValue* value)
+{
+	return value->data[0].v_pointer;
+}
+
+static gchar*
+value_faz_collect_value (GValue* value,
+                         guint n_collect_values,
+                         GTypeCValue* collect_values,
+                         guint collect_flags)
+{
+	if (collect_values[0].v_pointer) {
+		Faz * object;
+		object = collect_values[0].v_pointer;
+		if (object->parent_instance.g_class == NULL) {
+			return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
+		} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
+			return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
+		}
+		value->data[0].v_pointer = faz_ref (object);
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	return NULL;
+}
+
+static gchar*
+value_faz_lcopy_value (const GValue* value,
+                       guint n_collect_values,
+                       GTypeCValue* collect_values,
+                       guint collect_flags)
+{
+	Faz ** object_p;
+	object_p = collect_values[0].v_pointer;
+	if (!object_p) {
+		return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+	}
+	if (!value->data[0].v_pointer) {
+		*object_p = NULL;
+	} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
+		*object_p = value->data[0].v_pointer;
+	} else {
+		*object_p = faz_ref (value->data[0].v_pointer);
+	}
+	return NULL;
+}
+
+GParamSpec*
+param_spec_faz (const gchar* name,
+                const gchar* nick,
+                const gchar* blurb,
+                GType object_type,
+                GParamFlags flags)
+{
+	ParamSpecFaz* spec;
+	g_return_val_if_fail (g_type_is_a (object_type, TYPE_FAZ), NULL);
+	spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
+	G_PARAM_SPEC (spec)->value_type = object_type;
+	return G_PARAM_SPEC (spec);
+}
+
+gpointer
+value_get_faz (const GValue* value)
+{
+	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_FAZ), NULL);
+	return value->data[0].v_pointer;
+}
+
+void
+value_set_faz (GValue* value,
+               gpointer v_object)
+{
+	Faz * old;
+	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_FAZ));
+	old = value->data[0].v_pointer;
+	if (v_object) {
+		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_FAZ));
+		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
+		value->data[0].v_pointer = v_object;
+		faz_ref (value->data[0].v_pointer);
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	if (old) {
+		faz_unref (old);
+	}
+}
+
+void
+value_take_faz (GValue* value,
+                gpointer v_object)
+{
+	Faz * old;
+	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_FAZ));
+	old = value->data[0].v_pointer;
+	if (v_object) {
+		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_FAZ));
+		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
+		value->data[0].v_pointer = v_object;
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	if (old) {
+		faz_unref (old);
+	}
+}
+
+static void
+faz_class_init (FazClass * klass,
+                gpointer klass_data)
+{
+	faz_parent_class = g_type_class_peek_parent (klass);
+	((FazClass *) klass)->finalize = faz_finalize;
+	faz_signals[FAZ_TEST_SIGNAL] = g_signal_new ("test", TYPE_FAZ, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_STRING__STRING, G_TYPE_STRING, 1, G_TYPE_STRING);
+}
+
+static void
+faz_instance_init (Faz * self,
+                   gpointer klass)
+{
+	self->ref_count = 1;
+}
+
+static void
+faz_finalize (Faz * obj)
+{
+	Faz * self;
+	self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_FAZ, Faz);
+	g_signal_handlers_destroy (self);
+}
+
+static GType
+faz_get_type_once (void)
+{
+	static const GTypeValueTable g_define_type_value_table = { value_faz_init, value_faz_free_value, value_faz_copy_value, value_faz_peek_pointer, "p", value_faz_collect_value, "p", value_faz_lcopy_value };
+	static const GTypeInfo g_define_type_info = { sizeof (FazClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) faz_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Faz), 0, (GInstanceInitFunc) faz_instance_init, &g_define_type_value_table };
+	static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
+	GType faz_type_id;
+	faz_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Faz", &g_define_type_info, &g_define_type_fundamental_info, 0);
+	return faz_type_id;
+}
+
+GType
+faz_get_type (void)
+{
+	static volatile gsize faz_type_id__once = 0;
+	if (g_once_init_enter (&faz_type_id__once)) {
+		GType faz_type_id;
+		faz_type_id = faz_get_type_once ();
+		g_once_init_leave (&faz_type_id__once, faz_type_id);
+	}
+	return faz_type_id__once;
+}
+
+gpointer
+faz_ref (gpointer instance)
+{
+	Faz * self;
+	self = instance;
+	g_atomic_int_inc (&self->ref_count);
+	return instance;
+}
+
+void
+faz_unref (gpointer instance)
+{
+	Faz * self;
+	self = instance;
+	if (g_atomic_int_dec_and_test (&self->ref_count)) {
+		FAZ_GET_CLASS (self)->finalize (self);
+		g_type_free_instance ((GTypeInstance *) self);
+	}
+}
+
+static gchar*
+_vala_lambda2_ (Boo* self,
+                Faz* f,
+                const gchar* s)
+{
+	gchar* _tmp0_;
+	gchar* result;
+	g_return_val_if_fail (IS_FAZ (f), NULL);
+	g_return_val_if_fail (s != NULL, NULL);
+	_vala_assert (g_strcmp0 (s, "faz") == 0, "s == \"faz\"");
+	_tmp0_ = g_strdup (s);
+	result = _tmp0_;
+	return result;
+}
+
+static gchar*
+__vala_lambda2__faz_func (Faz* faz,
+                          const gchar* s,
+                          gpointer self)
+{
+	gchar* result;
+	result = _vala_lambda2_ ((Boo*) self, faz, s);
+	return result;
+}
+
+Boo*
+boo_construct (GType object_type)
+{
+	Boo* self = NULL;
+	Faz* faz = NULL;
+	Faz* _tmp0_;
+	FazFunc func = NULL;
+	gpointer func_target;
+	GDestroyNotify func_target_destroy_notify;
+	gchar* _tmp1_ = NULL;
+	gchar* _tmp2_;
+	guint _tmp3_;
+	gchar* _tmp4_ = NULL;
+	gchar* _tmp5_;
+	self = (Boo*) g_type_create_instance (object_type);
+	_tmp0_ = faz_new ();
+	faz = _tmp0_;
+	func = __vala_lambda2__faz_func;
+	func_target = boo_ref (self);
+	func_target_destroy_notify = boo_unref;
+	g_signal_connect (faz, "test", (GCallback) __vala_lambda2__faz_func, self);
+	g_signal_emit (faz, faz_signals[FAZ_TEST_SIGNAL], 0, "faz", &_tmp1_);
+	_tmp2_ = _tmp1_;
+	_vala_assert (g_strcmp0 (_tmp2_, "faz") == 0, "faz.test (\"faz\") == \"faz\"");
+	_g_free0 (_tmp2_);
+	g_signal_parse_name ("test", TYPE_FAZ, &_tmp3_, NULL, FALSE);
+	g_signal_handlers_disconnect_matched (faz, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp3_, 0, NULL, (GCallback) __vala_lambda2__faz_func, self);
+	g_signal_emit (faz, faz_signals[FAZ_TEST_SIGNAL], 0, "boo", &_tmp4_);
+	_tmp5_ = _tmp4_;
+	_g_free0 (_tmp5_);
+	(func_target_destroy_notify == NULL) ? NULL : (func_target_destroy_notify (func_target), NULL);
+	func = NULL;
+	func_target = NULL;
+	func_target_destroy_notify = NULL;
+	_faz_unref0 (faz);
+	return self;
+}
+
+Boo*
+boo_new (void)
+{
+	return boo_construct (TYPE_BOO);
+}
+
+static gchar*
+_vala_lambda3_ (Boo* self,
+                Faz* f,
+                const gchar* s)
+{
+	gchar* _tmp0_;
+	gchar* result;
+	g_return_val_if_fail (IS_FAZ (f), NULL);
+	g_return_val_if_fail (s != NULL, NULL);
+	_vala_assert (g_strcmp0 (s, "faz") == 0, "s == \"faz\"");
+	_tmp0_ = g_strdup (s);
+	result = _tmp0_;
+	return result;
+}
+
+static gchar*
+__vala_lambda3__faz_func (Faz* faz,
+                          const gchar* s,
+                          gpointer self)
+{
+	gchar* result;
+	result = _vala_lambda3_ ((Boo*) self, faz, s);
+	return result;
+}
+
+void
+boo_run (Boo* self)
+{
+	Faz* faz = NULL;
+	Faz* _tmp0_;
+	FazFunc func = NULL;
+	gpointer func_target;
+	GDestroyNotify func_target_destroy_notify;
+	gchar* _tmp1_ = NULL;
+	gchar* _tmp2_;
+	guint _tmp3_;
+	gchar* _tmp4_ = NULL;
+	gchar* _tmp5_;
+	g_return_if_fail (IS_BOO (self));
+	_tmp0_ = faz_new ();
+	faz = _tmp0_;
+	func = __vala_lambda3__faz_func;
+	func_target = boo_ref (self);
+	func_target_destroy_notify = boo_unref;
+	g_signal_connect (faz, "test", (GCallback) __vala_lambda3__faz_func, self);
+	g_signal_emit (faz, faz_signals[FAZ_TEST_SIGNAL], 0, "faz", &_tmp1_);
+	_tmp2_ = _tmp1_;
+	_vala_assert (g_strcmp0 (_tmp2_, "faz") == 0, "faz.test (\"faz\") == \"faz\"");
+	_g_free0 (_tmp2_);
+	g_signal_parse_name ("test", TYPE_FAZ, &_tmp3_, NULL, FALSE);
+	g_signal_handlers_disconnect_matched (faz, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp3_, 0, NULL, (GCallback) __vala_lambda3__faz_func, self);
+	g_signal_emit (faz, faz_signals[FAZ_TEST_SIGNAL], 0, "boo", &_tmp4_);
+	_tmp5_ = _tmp4_;
+	_g_free0 (_tmp5_);
+	(func_target_destroy_notify == NULL) ? NULL : (func_target_destroy_notify (func_target), NULL);
+	func = NULL;
+	func_target = NULL;
+	func_target_destroy_notify = NULL;
+	_faz_unref0 (faz);
+}
+
+static void
+value_boo_init (GValue* value)
+{
+	value->data[0].v_pointer = NULL;
+}
+
+static void
+value_boo_free_value (GValue* value)
+{
+	if (value->data[0].v_pointer) {
+		boo_unref (value->data[0].v_pointer);
+	}
+}
+
+static void
+value_boo_copy_value (const GValue* src_value,
+                      GValue* dest_value)
+{
+	if (src_value->data[0].v_pointer) {
+		dest_value->data[0].v_pointer = boo_ref (src_value->data[0].v_pointer);
+	} else {
+		dest_value->data[0].v_pointer = NULL;
+	}
+}
+
+static gpointer
+value_boo_peek_pointer (const GValue* value)
+{
+	return value->data[0].v_pointer;
+}
+
+static gchar*
+value_boo_collect_value (GValue* value,
+                         guint n_collect_values,
+                         GTypeCValue* collect_values,
+                         guint collect_flags)
+{
+	if (collect_values[0].v_pointer) {
+		Boo * object;
+		object = collect_values[0].v_pointer;
+		if (object->parent_instance.g_class == NULL) {
+			return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
+		} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
+			return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
+		}
+		value->data[0].v_pointer = boo_ref (object);
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	return NULL;
+}
+
+static gchar*
+value_boo_lcopy_value (const GValue* value,
+                       guint n_collect_values,
+                       GTypeCValue* collect_values,
+                       guint collect_flags)
+{
+	Boo ** object_p;
+	object_p = collect_values[0].v_pointer;
+	if (!object_p) {
+		return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
+	}
+	if (!value->data[0].v_pointer) {
+		*object_p = NULL;
+	} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
+		*object_p = value->data[0].v_pointer;
+	} else {
+		*object_p = boo_ref (value->data[0].v_pointer);
+	}
+	return NULL;
+}
+
+GParamSpec*
+param_spec_boo (const gchar* name,
+                const gchar* nick,
+                const gchar* blurb,
+                GType object_type,
+                GParamFlags flags)
+{
+	ParamSpecBoo* spec;
+	g_return_val_if_fail (g_type_is_a (object_type, TYPE_BOO), NULL);
+	spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
+	G_PARAM_SPEC (spec)->value_type = object_type;
+	return G_PARAM_SPEC (spec);
+}
+
+gpointer
+value_get_boo (const GValue* value)
+{
+	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_BOO), NULL);
+	return value->data[0].v_pointer;
+}
+
+void
+value_set_boo (GValue* value,
+               gpointer v_object)
+{
+	Boo * old;
+	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_BOO));
+	old = value->data[0].v_pointer;
+	if (v_object) {
+		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_BOO));
+		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
+		value->data[0].v_pointer = v_object;
+		boo_ref (value->data[0].v_pointer);
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	if (old) {
+		boo_unref (old);
+	}
+}
+
+void
+value_take_boo (GValue* value,
+                gpointer v_object)
+{
+	Boo * old;
+	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_BOO));
+	old = value->data[0].v_pointer;
+	if (v_object) {
+		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_BOO));
+		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
+		value->data[0].v_pointer = v_object;
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	if (old) {
+		boo_unref (old);
+	}
+}
+
+static void
+boo_class_init (BooClass * klass,
+                gpointer klass_data)
+{
+	boo_parent_class = g_type_class_peek_parent (klass);
+	((BooClass *) klass)->finalize = boo_finalize;
+}
+
+static void
+boo_instance_init (Boo * self,
+                   gpointer klass)
+{
+	self->ref_count = 1;
+}
+
+static void
+boo_finalize (Boo * obj)
+{
+	Boo * self;
+	self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_BOO, Boo);
+	g_signal_handlers_destroy (self);
+}
+
+static GType
+boo_get_type_once (void)
+{
+	static const GTypeValueTable g_define_type_value_table = { value_boo_init, value_boo_free_value, value_boo_copy_value, value_boo_peek_pointer, "p", value_boo_collect_value, "p", value_boo_lcopy_value };
+	static const GTypeInfo g_define_type_info = { sizeof (BooClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) boo_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Boo), 0, (GInstanceInitFunc) boo_instance_init, &g_define_type_value_table };
+	static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
+	GType boo_type_id;
+	boo_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Boo", &g_define_type_info, &g_define_type_fundamental_info, 0);
+	return boo_type_id;
+}
+
+GType
+boo_get_type (void)
+{
+	static volatile gsize boo_type_id__once = 0;
+	if (g_once_init_enter (&boo_type_id__once)) {
+		GType boo_type_id;
+		boo_type_id = boo_get_type_once ();
+		g_once_init_leave (&boo_type_id__once, boo_type_id);
+	}
+	return boo_type_id__once;
+}
+
+gpointer
+boo_ref (gpointer instance)
+{
+	Boo * self;
+	self = instance;
+	g_atomic_int_inc (&self->ref_count);
+	return instance;
+}
+
+void
+boo_unref (gpointer instance)
+{
+	Boo * self;
+	self = instance;
+	if (g_atomic_int_dec_and_test (&self->ref_count)) {
+		BOO_GET_CLASS (self)->finalize (self);
+		g_type_free_instance ((GTypeInstance *) self);
+	}
+}
+
+static gchar*
+_vala_lambda4_ (Foo* f,
+                const gchar* s)
+{
+	gchar* _tmp0_;
+	gchar* result;
+	g_return_val_if_fail (IS_FOO (f), NULL);
+	g_return_val_if_fail (s != NULL, NULL);
+	_vala_assert (g_strcmp0 (s, "foo") == 0, "s == \"foo\"");
+	_tmp0_ = g_strdup (s);
+	result = _tmp0_;
+	return result;
+}
+
+static gchar*
+__vala_lambda4__foo_func (Foo* foo,
+                          const gchar* s,
+                          gpointer self)
+{
+	gchar* result;
+	result = _vala_lambda4_ (foo, s);
+	return result;
+}
+
+static gchar*
+_vala_lambda5_ (Faz* f,
+                const gchar* s)
+{
+	gchar* _tmp0_;
+	gchar* result;
+	g_return_val_if_fail (IS_FAZ (f), NULL);
+	g_return_val_if_fail (s != NULL, NULL);
+	_vala_assert (g_strcmp0 (s, "faz") == 0, "s == \"faz\"");
+	_tmp0_ = g_strdup (s);
+	result = _tmp0_;
+	return result;
+}
+
+static gchar*
+__vala_lambda5__faz_func (Faz* faz,
+                          const gchar* s,
+                          gpointer self)
+{
+	gchar* result;
+	result = _vala_lambda5_ (faz, s);
+	return result;
+}
+
+static void
+_vala_main (void)
+{
+	{
+		Bar* bar = NULL;
+		Bar* _tmp0_;
+		Foo* foo = NULL;
+		Foo* _tmp1_;
+		FooFunc func = NULL;
+		gpointer func_target;
+		GDestroyNotify func_target_destroy_notify;
+		gchar* _tmp2_ = NULL;
+		gchar* _tmp3_;
+		guint _tmp4_;
+		gchar* _tmp5_ = NULL;
+		gchar* _tmp6_;
+		_tmp0_ = bar_new ();
+		bar = _tmp0_;
+		bar_run (bar);
+		_tmp1_ = foo_new ();
+		foo = _tmp1_;
+		func = __vala_lambda4__foo_func;
+		func_target = NULL;
+		func_target_destroy_notify = NULL;
+		g_signal_connect (foo, "test", (GCallback) __vala_lambda4__foo_func, NULL);
+		g_signal_emit (foo, foo_signals[FOO_TEST_SIGNAL], 0, "foo", &_tmp2_);
+		_tmp3_ = _tmp2_;
+		_vala_assert (g_strcmp0 (_tmp3_, "foo") == 0, "foo.test (\"foo\") == \"foo\"");
+		_g_free0 (_tmp3_);
+		g_signal_parse_name ("test", TYPE_FOO, &_tmp4_, NULL, FALSE);
+		g_signal_handlers_disconnect_matched (foo, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp4_, 0, NULL, (GCallback) __vala_lambda4__foo_func, NULL);
+		g_signal_emit (foo, foo_signals[FOO_TEST_SIGNAL], 0, "bar", &_tmp5_);
+		_tmp6_ = _tmp5_;
+		_g_free0 (_tmp6_);
+		(func_target_destroy_notify == NULL) ? NULL : (func_target_destroy_notify (func_target), NULL);
+		func = NULL;
+		func_target = NULL;
+		func_target_destroy_notify = NULL;
+		_g_object_unref0 (foo);
+		_g_object_unref0 (bar);
+	}
+	{
+		Boo* boo = NULL;
+		Boo* _tmp7_;
+		Faz* faz = NULL;
+		Faz* _tmp8_;
+		FazFunc func = NULL;
+		gpointer func_target;
+		GDestroyNotify func_target_destroy_notify;
+		gchar* _tmp9_ = NULL;
+		gchar* _tmp10_;
+		guint _tmp11_;
+		gchar* _tmp12_ = NULL;
+		gchar* _tmp13_;
+		_tmp7_ = boo_new ();
+		boo = _tmp7_;
+		boo_run (boo);
+		_tmp8_ = faz_new ();
+		faz = _tmp8_;
+		func = __vala_lambda5__faz_func;
+		func_target = NULL;
+		func_target_destroy_notify = NULL;
+		g_signal_connect (faz, "test", (GCallback) __vala_lambda5__faz_func, NULL);
+		g_signal_emit (faz, faz_signals[FAZ_TEST_SIGNAL], 0, "faz", &_tmp9_);
+		_tmp10_ = _tmp9_;
+		_vala_assert (g_strcmp0 (_tmp10_, "faz") == 0, "faz.test (\"faz\") == \"faz\"");
+		_g_free0 (_tmp10_);
+		g_signal_parse_name ("test", TYPE_FAZ, &_tmp11_, NULL, FALSE);
+		g_signal_handlers_disconnect_matched (faz, G_SIGNAL_MATCH_ID | G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_DATA, _tmp11_, 0, NULL, (GCallback) __vala_lambda5__faz_func, NULL);
+		g_signal_emit (faz, faz_signals[FAZ_TEST_SIGNAL], 0, "boo", &_tmp12_);
+		_tmp13_ = _tmp12_;
+		_g_free0 (_tmp13_);
+		(func_target_destroy_notify == NULL) ? NULL : (func_target_destroy_notify (func_target), NULL);
+		func = NULL;
+		func_target = NULL;
+		func_target_destroy_notify = NULL;
+		_faz_unref0 (faz);
+		_boo_unref0 (boo);
+	}
+}
+
+int
+main (int argc,
+      char ** argv)
+{
+	_vala_main ();
+	return 0;
+}
+
diff --git a/tests/objects/signals-lambda-delegate-2.vala b/tests/objects/signals-lambda-delegate-2.vala
new file mode 100644
index 000000000..8be4aaed0
--- /dev/null
+++ b/tests/objects/signals-lambda-delegate-2.vala
@@ -0,0 +1,94 @@
+delegate string FooFunc (Foo foo, string s);
+
+class Foo : Object {
+	public signal string test (string s);
+}
+
+class Bar : Object {
+	construct {
+		var foo = new Foo ();
+		FooFunc func = (f,s) => {
+			assert (s == "foo");
+			return s;
+		};
+		foo.test.connect (func);
+		assert (foo.test ("foo") == "foo");
+		foo.test.disconnect (func);
+		foo.test ("bar");
+	}
+
+	public void run () {
+		var foo = new Foo ();
+		FooFunc func = (f,s) => {
+			assert (s == "foo");
+			return s;
+		};
+		foo.test.connect (func);
+		assert (foo.test ("foo") == "foo");
+		foo.test.disconnect (func);
+		foo.test ("bar");
+	}
+}
+
+delegate string FazFunc (Faz faz, string s);
+
+class Faz {
+	public signal string test (string s);
+}
+
+class Boo {
+	public Boo () {
+		var faz = new Faz ();
+		FazFunc func = (f,s) => {
+			assert (s == "faz");
+			return s;
+		};
+		faz.test.connect (func);
+		assert (faz.test ("faz") == "faz");
+		faz.test.disconnect (func);
+		faz.test ("boo");
+	}
+
+	public void run () {
+		var faz = new Faz ();
+		FazFunc func = (f,s) => {
+			assert (s == "faz");
+			return s;
+		};
+		faz.test.connect (func);
+		assert (faz.test ("faz") == "faz");
+		faz.test.disconnect (func);
+		faz.test ("boo");
+	}
+}
+
+void main () {
+	{
+		var bar = new Bar ();
+		bar.run ();
+
+		var foo = new Foo ();
+		FooFunc func = (f,s) => {
+			assert (s == "foo");
+			return s;
+		};
+		foo.test.connect (func);
+		assert (foo.test ("foo") == "foo");
+		foo.test.disconnect (func);
+		foo.test ("bar");
+	}
+	{
+		var boo = new Boo ();
+		boo.run ();
+
+		var faz = new Faz ();
+		FazFunc func = (f,s) => {
+			assert (s == "faz");
+			return s;
+		};
+		faz.test.connect (func);
+		assert (faz.test ("faz") == "faz");
+		faz.test.disconnect (func);
+		faz.test ("boo");
+	}
+}