codegen: Consistently handle GLib.Error as boxed type

Use G_TYPE_ERROR and GBoxed API for all error domains.

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

8 files changed, 841 insertions, 39 deletions

diff --git a/codegen/valaccodeattribute.vala b/codegen/valaccodeattribute.vala
index 9b49fe9e1..3901e65d9 100644
--- a/codegen/valaccodeattribute.vala
+++ b/codegen/valaccodeattribute.vala
@@ -1174,7 +1174,7 @@ public class Vala.CCodeAttribute : AttributeCache {
 		} else if (node is PointerType || node is GenericType) {
 			return "POINTER";
 		} else if (node is ErrorType) {
-			return "POINTER";
+			return "BOXED";
 		} else if (node is ArrayType) {
 			unowned ArrayType array_type = (ArrayType) node;
 			if (array_type.element_type.type_symbol == CodeContext.get ().analyzer.string_type.type_symbol) {
@@ -1212,7 +1212,7 @@ public class Vala.CCodeAttribute : AttributeCache {
 				return get_ccode_lower_case_name (cl, "value_get_");
 			} else if (cl.base_class != null) {
 				return get_ccode_get_value_function (cl.base_class);
-			} else if (type_id == "G_TYPE_POINTER" || cl.is_error_base) {
+			} else if (type_id == "G_TYPE_POINTER") {
 				return "g_value_get_pointer";
 			} else {
 				return "g_value_get_boxed";
@@ -1232,6 +1232,8 @@ public class Vala.CCodeAttribute : AttributeCache {
 					return "g_value_get_int";
 				}
 			}
+		} else if (sym is ErrorDomain) {
+			return "g_value_get_boxed";
 		} else if (sym is Interface) {
 			foreach (var prereq in ((Interface) sym).get_prerequisites ()) {
 				var type_name = get_ccode_get_value_function (prereq.type_symbol);
@@ -1270,7 +1272,7 @@ public class Vala.CCodeAttribute : AttributeCache {
 				return get_ccode_lower_case_name (cl, "value_set_");
 			} else if (cl.base_class != null) {
 				return get_ccode_set_value_function (cl.base_class);
-			} else if (type_id == "G_TYPE_POINTER" || cl.is_error_base) {
+			} else if (type_id == "G_TYPE_POINTER") {
 				return "g_value_set_pointer";
 			} else {
 				return "g_value_set_boxed";
@@ -1290,6 +1292,8 @@ public class Vala.CCodeAttribute : AttributeCache {
 					return "g_value_set_int";
 				}
 			}
+		} else if (sym is ErrorDomain) {
+			return "g_value_set_boxed";
 		} else if (sym is Interface) {
 			foreach (var prereq in ((Interface) sym).get_prerequisites ()) {
 				var type_name = get_ccode_set_value_function (prereq.type_symbol);
@@ -1328,7 +1332,7 @@ public class Vala.CCodeAttribute : AttributeCache {
 				return get_ccode_lower_case_name (cl, "value_take_");
 			} else if (cl.base_class != null) {
 				return get_ccode_take_value_function (cl.base_class);
-			} else if (type_id == "G_TYPE_POINTER" || cl.is_error_base) {
+			} else if (type_id == "G_TYPE_POINTER") {
 				return "g_value_set_pointer";
 			} else {
 				return "g_value_take_boxed";
@@ -1348,6 +1352,8 @@ public class Vala.CCodeAttribute : AttributeCache {
 					return "g_value_take_int";
 				}
 			}
+		} else if (sym is ErrorDomain) {
+			return "g_value_take_boxed";
 		} else if (sym is Interface) {
 			foreach (var prereq in ((Interface) sym).get_prerequisites ()) {
 				var func = get_ccode_take_value_function (prereq.type_symbol);
@@ -1415,6 +1421,8 @@ public class Vala.CCodeAttribute : AttributeCache {
 						return "g_param_spec_int";
 					}
 				}
+			} else if (sym is ErrorDomain) {
+				return "g_param_spec_boxed";
 			} else if (sym is Struct) {
 				var type_id = get_ccode_type_id (sym);
 				if (type_id == "G_TYPE_INT") {
diff --git a/codegen/valagsignalmodule.vala b/codegen/valagsignalmodule.vala
index 4186859cf..7f02b17f1 100644
--- a/codegen/valagsignalmodule.vala
+++ b/codegen/valagsignalmodule.vala
@@ -413,7 +413,7 @@ public class Vala.GSignalModule : GObjectModule {
 		if (sig.return_type is PointerType || sig.return_type is GenericType) {
 			csignew.add_argument (new CCodeConstant ("G_TYPE_POINTER"));
 		} else if (sig.return_type is ErrorType) {
-			csignew.add_argument (new CCodeConstant ("G_TYPE_POINTER"));
+			csignew.add_argument (new CCodeConstant ("G_TYPE_ERROR"));
 		} else if (sig.return_type is ValueType && sig.return_type.nullable) {
 			csignew.add_argument (new CCodeConstant ("G_TYPE_POINTER"));
 		} else if (sig.return_type.type_symbol == null) {
@@ -469,7 +469,7 @@ public class Vala.GSignalModule : GObjectModule {
 			} else if (param.variable_type is PointerType || param.variable_type is GenericType || param.direction != ParameterDirection.IN) {
 				csignew.add_argument (new CCodeConstant ("G_TYPE_POINTER"));
 			} else if (param.variable_type is ErrorType) {
-				csignew.add_argument (new CCodeConstant ("G_TYPE_POINTER"));
+				csignew.add_argument (new CCodeConstant ("G_TYPE_ERROR"));
 			} else if (param.variable_type is ValueType && param.variable_type.nullable) {
 				csignew.add_argument (new CCodeConstant ("G_TYPE_POINTER"));
 			} else {
diff --git a/codegen/valagtypemodule.vala b/codegen/valagtypemodule.vala
index 2ad38d650..c1f7a1df1 100644
--- a/codegen/valagtypemodule.vala
+++ b/codegen/valagtypemodule.vala
@@ -1963,6 +1963,9 @@ public class Vala.GTypeModule : GErrorModule {
 			} else {
 				cspec.add_argument (new CCodeConstant (get_ccode_default_value (type_symbol)));
 			}
+		} else if (type_symbol is ErrorDomain) {
+			cspec.call = new CCodeIdentifier ("g_param_spec_boxed");
+			cspec.add_argument (new CCodeIdentifier ("G_TYPE_ERROR"));
 		} else if (type_symbol is Struct) {
 			unowned Struct st = (Struct) type_symbol;
 			var type_id = get_ccode_type_id (st);
diff --git a/tests/Makefile.am b/tests/Makefile.am
index 499d7f0d4..1b8d17ce9 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -564,6 +564,7 @@ TESTS = \
 	objects/property-dynamic-not-supported.test \
 	objects/property-dynamic-type-inference.vala \
 	objects/property-enum.vala \
+	objects/property-error.vala \
 	objects/property-notify.vala \
 	objects/property-notify-owned-getter.vala \
 	objects/property-ownership.vala \
diff --git a/tests/objects/property-error.c-expected b/tests/objects/property-error.c-expected
new file mode 100644
index 000000000..9aca938be
--- /dev/null
+++ b/tests/objects/property-error.c-expected
@@ -0,0 +1,745 @@
+/* objects_property_error.c generated by valac, the Vala compiler
+ * generated from objects_property_error.vala, do not modify */
+
+#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_ERROR (foo_error_get_type ())
+
+#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;
+#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
+typedef struct _ParamSpecBar ParamSpecBar;
+
+#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 struct _FooPrivate FooPrivate;
+enum  {
+	FOO_0_PROPERTY,
+	FOO_BAR_PROPERTY,
+	FOO_FOO_PROPERTY,
+	FOO_MANAM_PROPERTY,
+	FOO_NUM_PROPERTIES
+};
+static GParamSpec* foo_properties[FOO_NUM_PROPERTIES];
+#define _bar_unref0(var) ((var == NULL) ? NULL : (var = (bar_unref (var), NULL)))
+#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_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);
+
+typedef enum  {
+	FOO_ERROR_BAD
+} FooError;
+#define FOO_ERROR foo_error_quark ()
+
+struct _Bar {
+	GTypeInstance parent_instance;
+	volatile int ref_count;
+	BarPrivate * priv;
+};
+
+struct _BarClass {
+	GTypeClass parent_class;
+	void (*finalize) (Bar *self);
+};
+
+struct _BarPrivate {
+	GError* _bar;
+	GError* _foo;
+};
+
+struct _ParamSpecBar {
+	GParamSpec parent_instance;
+};
+
+struct _Foo {
+	GObject parent_instance;
+	FooPrivate * priv;
+};
+
+struct _FooClass {
+	GObjectClass parent_class;
+};
+
+struct _FooPrivate {
+	GError* _bar;
+	GError* _foo;
+	GError* _manam;
+};
+
+static gint Bar_private_offset;
+static gpointer bar_parent_class = NULL;
+static gint Foo_private_offset;
+static gpointer foo_parent_class = NULL;
+
+VALA_EXTERN GQuark foo_error_quark (void);
+GType foo_error_get_type (void) G_GNUC_CONST ;
+VALA_EXTERN gpointer bar_ref (gpointer instance);
+VALA_EXTERN void bar_unref (gpointer instance);
+VALA_EXTERN GParamSpec* param_spec_bar (const gchar* name,
+                            const gchar* nick,
+                            const gchar* blurb,
+                            GType object_type,
+                            GParamFlags flags);
+VALA_EXTERN void value_set_bar (GValue* value,
+                    gpointer v_object);
+VALA_EXTERN void value_take_bar (GValue* value,
+                     gpointer v_object);
+VALA_EXTERN gpointer value_get_bar (const GValue* value);
+VALA_EXTERN GType bar_get_type (void) G_GNUC_CONST ;
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (Bar, bar_unref)
+VALA_EXTERN Bar* bar_new (void);
+VALA_EXTERN Bar* bar_construct (GType object_type);
+VALA_EXTERN GError* bar_get_bar (Bar* self);
+VALA_EXTERN void bar_set_bar (Bar* self,
+                  GError* value);
+VALA_EXTERN GError* bar_get_foo (Bar* self);
+VALA_EXTERN void bar_set_foo (Bar* self,
+                  GError* value);
+static void bar_finalize (Bar * obj);
+static GType bar_get_type_once (void);
+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);
+VALA_EXTERN GError* foo_get_bar (Foo* self);
+VALA_EXTERN void foo_set_bar (Foo* self,
+                  GError* value);
+VALA_EXTERN GError* foo_get_foo (Foo* self);
+VALA_EXTERN void foo_set_foo (Foo* self,
+                  GError* value);
+VALA_EXTERN GError* foo_get_manam (Foo* self);
+VALA_EXTERN void foo_set_manam (Foo* self,
+                    GError* value);
+static void foo_finalize (GObject * obj);
+static GType foo_get_type_once (void);
+static void _vala_foo_get_property (GObject * object,
+                             guint property_id,
+                             GValue * value,
+                             GParamSpec * pspec);
+static void _vala_foo_set_property (GObject * object,
+                             guint property_id,
+                             const GValue * value,
+                             GParamSpec * pspec);
+static void _vala_main (void);
+
+GQuark
+foo_error_quark (void)
+{
+	return g_quark_from_static_string ("foo-error-quark");
+}
+
+static GType
+foo_error_get_type_once (void)
+{
+	static const GEnumValue values[] = {{FOO_ERROR_BAD, "FOO_ERROR_BAD", "bad"}, {0, NULL, NULL}};
+	GType foo_error_type_id;
+	foo_error_type_id = g_enum_register_static ("FooError", values);
+	return foo_error_type_id;
+}
+
+GType
+foo_error_get_type (void)
+{
+	static volatile gsize foo_error_type_id__once = 0;
+	if (g_once_init_enter (&foo_error_type_id__once)) {
+		GType foo_error_type_id;
+		foo_error_type_id = foo_error_get_type_once ();
+		g_once_init_leave (&foo_error_type_id__once, foo_error_type_id);
+	}
+	return foo_error_type_id__once;
+}
+
+static inline gpointer
+bar_get_instance_private (Bar* self)
+{
+	return G_STRUCT_MEMBER_P (self, Bar_private_offset);
+}
+
+Bar*
+bar_construct (GType object_type)
+{
+	Bar* self = NULL;
+	self = (Bar*) g_type_create_instance (object_type);
+	return self;
+}
+
+Bar*
+bar_new (void)
+{
+	return bar_construct (TYPE_BAR);
+}
+
+GError*
+bar_get_bar (Bar* self)
+{
+	GError* result;
+	GError* _tmp0_;
+	g_return_val_if_fail (IS_BAR (self), NULL);
+	_tmp0_ = self->priv->_bar;
+	result = _tmp0_;
+	return result;
+}
+
+static gpointer
+_g_error_copy0 (gpointer self)
+{
+	return self ? g_error_copy (self) : NULL;
+}
+
+void
+bar_set_bar (Bar* self,
+             GError* value)
+{
+	GError* _tmp0_;
+	g_return_if_fail (IS_BAR (self));
+	_tmp0_ = _g_error_copy0 (value);
+	_g_error_free0 (self->priv->_bar);
+	self->priv->_bar = _tmp0_;
+}
+
+GError*
+bar_get_foo (Bar* self)
+{
+	GError* result;
+	GError* _tmp0_;
+	g_return_val_if_fail (IS_BAR (self), NULL);
+	_tmp0_ = self->priv->_foo;
+	result = _tmp0_;
+	return result;
+}
+
+void
+bar_set_foo (Bar* self,
+             GError* value)
+{
+	GError* _tmp0_;
+	g_return_if_fail (IS_BAR (self));
+	_tmp0_ = _g_error_copy0 (value);
+	_g_error_free0 (self->priv->_foo);
+	self->priv->_foo = _tmp0_;
+}
+
+static void
+value_bar_init (GValue* value)
+{
+	value->data[0].v_pointer = NULL;
+}
+
+static void
+value_bar_free_value (GValue* value)
+{
+	if (value->data[0].v_pointer) {
+		bar_unref (value->data[0].v_pointer);
+	}
+}
+
+static void
+value_bar_copy_value (const GValue* src_value,
+                      GValue* dest_value)
+{
+	if (src_value->data[0].v_pointer) {
+		dest_value->data[0].v_pointer = bar_ref (src_value->data[0].v_pointer);
+	} else {
+		dest_value->data[0].v_pointer = NULL;
+	}
+}
+
+static gpointer
+value_bar_peek_pointer (const GValue* value)
+{
+	return value->data[0].v_pointer;
+}
+
+static gchar*
+value_bar_collect_value (GValue* value,
+                         guint n_collect_values,
+                         GTypeCValue* collect_values,
+                         guint collect_flags)
+{
+	if (collect_values[0].v_pointer) {
+		Bar * 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 = bar_ref (object);
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	return NULL;
+}
+
+static gchar*
+value_bar_lcopy_value (const GValue* value,
+                       guint n_collect_values,
+                       GTypeCValue* collect_values,
+                       guint collect_flags)
+{
+	Bar ** 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 = bar_ref (value->data[0].v_pointer);
+	}
+	return NULL;
+}
+
+GParamSpec*
+param_spec_bar (const gchar* name,
+                const gchar* nick,
+                const gchar* blurb,
+                GType object_type,
+                GParamFlags flags)
+{
+	ParamSpecBar* spec;
+	g_return_val_if_fail (g_type_is_a (object_type, TYPE_BAR), 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_bar (const GValue* value)
+{
+	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_BAR), NULL);
+	return value->data[0].v_pointer;
+}
+
+void
+value_set_bar (GValue* value,
+               gpointer v_object)
+{
+	Bar * old;
+	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_BAR));
+	old = value->data[0].v_pointer;
+	if (v_object) {
+		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_BAR));
+		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;
+		bar_ref (value->data[0].v_pointer);
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	if (old) {
+		bar_unref (old);
+	}
+}
+
+void
+value_take_bar (GValue* value,
+                gpointer v_object)
+{
+	Bar * old;
+	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_BAR));
+	old = value->data[0].v_pointer;
+	if (v_object) {
+		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_BAR));
+		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) {
+		bar_unref (old);
+	}
+}
+
+static void
+bar_class_init (BarClass * klass,
+                gpointer klass_data)
+{
+	bar_parent_class = g_type_class_peek_parent (klass);
+	((BarClass *) klass)->finalize = bar_finalize;
+	g_type_class_adjust_private_offset (klass, &Bar_private_offset);
+}
+
+static void
+bar_instance_init (Bar * self,
+                   gpointer klass)
+{
+	self->priv = bar_get_instance_private (self);
+	self->ref_count = 1;
+}
+
+static void
+bar_finalize (Bar * obj)
+{
+	Bar * self;
+	self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_BAR, Bar);
+	g_signal_handlers_destroy (self);
+	_g_error_free0 (self->priv->_bar);
+	_g_error_free0 (self->priv->_foo);
+}
+
+static GType
+bar_get_type_once (void)
+{
+	static const GTypeValueTable g_define_type_value_table = { value_bar_init, value_bar_free_value, value_bar_copy_value, value_bar_peek_pointer, "p", value_bar_collect_value, "p", value_bar_lcopy_value };
+	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, &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 bar_type_id;
+	bar_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Bar", &g_define_type_info, &g_define_type_fundamental_info, 0);
+	Bar_private_offset = g_type_add_instance_private (bar_type_id, sizeof (BarPrivate));
+	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;
+}
+
+gpointer
+bar_ref (gpointer instance)
+{
+	Bar * self;
+	self = instance;
+	g_atomic_int_inc (&self->ref_count);
+	return instance;
+}
+
+void
+bar_unref (gpointer instance)
+{
+	Bar * self;
+	self = instance;
+	if (g_atomic_int_dec_and_test (&self->ref_count)) {
+		BAR_GET_CLASS (self)->finalize (self);
+		g_type_free_instance ((GTypeInstance *) self);
+	}
+}
+
+static inline gpointer
+foo_get_instance_private (Foo* self)
+{
+	return G_STRUCT_MEMBER_P (self, Foo_private_offset);
+}
+
+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);
+}
+
+GError*
+foo_get_bar (Foo* self)
+{
+	GError* result;
+	GError* _tmp0_;
+	g_return_val_if_fail (IS_FOO (self), NULL);
+	_tmp0_ = self->priv->_bar;
+	result = _tmp0_;
+	return result;
+}
+
+void
+foo_set_bar (Foo* self,
+             GError* value)
+{
+	GError* old_value;
+	g_return_if_fail (IS_FOO (self));
+	old_value = foo_get_bar (self);
+	if (old_value != value) {
+		GError* _tmp0_;
+		_tmp0_ = _g_error_copy0 (value);
+		_g_error_free0 (self->priv->_bar);
+		self->priv->_bar = _tmp0_;
+		g_object_notify_by_pspec ((GObject *) self, foo_properties[FOO_BAR_PROPERTY]);
+	}
+}
+
+GError*
+foo_get_foo (Foo* self)
+{
+	GError* result;
+	GError* _tmp0_;
+	g_return_val_if_fail (IS_FOO (self), NULL);
+	_tmp0_ = self->priv->_foo;
+	result = _tmp0_;
+	return result;
+}
+
+void
+foo_set_foo (Foo* self,
+             GError* value)
+{
+	GError* old_value;
+	g_return_if_fail (IS_FOO (self));
+	old_value = foo_get_foo (self);
+	if (old_value != value) {
+		GError* _tmp0_;
+		_tmp0_ = _g_error_copy0 (value);
+		_g_error_free0 (self->priv->_foo);
+		self->priv->_foo = _tmp0_;
+		g_object_notify_by_pspec ((GObject *) self, foo_properties[FOO_FOO_PROPERTY]);
+	}
+}
+
+GError*
+foo_get_manam (Foo* self)
+{
+	GError* result;
+	GError* _tmp0_;
+	GError* _tmp1_;
+	g_return_val_if_fail (IS_FOO (self), NULL);
+	_tmp0_ = self->priv->_manam;
+	_tmp1_ = _g_error_copy0 (_tmp0_);
+	result = _tmp1_;
+	return result;
+}
+
+void
+foo_set_manam (Foo* self,
+               GError* value)
+{
+	GError* old_value;
+	g_return_if_fail (IS_FOO (self));
+	old_value = foo_get_manam (self);
+	if (old_value != value) {
+		GError* _tmp0_;
+		_tmp0_ = _g_error_copy0 (value);
+		_g_error_free0 (self->priv->_manam);
+		self->priv->_manam = _tmp0_;
+		g_object_notify_by_pspec ((GObject *) self, foo_properties[FOO_MANAM_PROPERTY]);
+	}
+	_g_error_free0 (old_value);
+}
+
+static void
+foo_class_init (FooClass * klass,
+                gpointer klass_data)
+{
+	foo_parent_class = g_type_class_peek_parent (klass);
+	g_type_class_adjust_private_offset (klass, &Foo_private_offset);
+	G_OBJECT_CLASS (klass)->get_property = _vala_foo_get_property;
+	G_OBJECT_CLASS (klass)->set_property = _vala_foo_set_property;
+	G_OBJECT_CLASS (klass)->finalize = foo_finalize;
+	g_object_class_install_property (G_OBJECT_CLASS (klass), FOO_BAR_PROPERTY, foo_properties[FOO_BAR_PROPERTY] = g_param_spec_boxed ("bar", "bar", "bar", G_TYPE_ERROR, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
+	g_object_class_install_property (G_OBJECT_CLASS (klass), FOO_FOO_PROPERTY, foo_properties[FOO_FOO_PROPERTY] = g_param_spec_boxed ("foo", "foo", "foo", G_TYPE_ERROR, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
+	g_object_class_install_property (G_OBJECT_CLASS (klass), FOO_MANAM_PROPERTY, foo_properties[FOO_MANAM_PROPERTY] = g_param_spec_boxed ("manam", "manam", "manam", G_TYPE_ERROR, G_PARAM_STATIC_STRINGS | G_PARAM_READABLE | G_PARAM_WRITABLE));
+}
+
+static void
+foo_instance_init (Foo * self,
+                   gpointer klass)
+{
+	self->priv = foo_get_instance_private (self);
+}
+
+static void
+foo_finalize (GObject * obj)
+{
+	Foo * self;
+	self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_FOO, Foo);
+	_g_error_free0 (self->priv->_bar);
+	_g_error_free0 (self->priv->_foo);
+	_g_error_free0 (self->priv->_manam);
+	G_OBJECT_CLASS (foo_parent_class)->finalize (obj);
+}
+
+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);
+	Foo_private_offset = g_type_add_instance_private (foo_type_id, sizeof (FooPrivate));
+	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 void
+_vala_foo_get_property (GObject * object,
+                        guint property_id,
+                        GValue * value,
+                        GParamSpec * pspec)
+{
+	Foo * self;
+	self = G_TYPE_CHECK_INSTANCE_CAST (object, TYPE_FOO, Foo);
+	switch (property_id) {
+		case FOO_BAR_PROPERTY:
+		g_value_set_boxed (value, foo_get_bar (self));
+		break;
+		case FOO_FOO_PROPERTY:
+		g_value_set_boxed (value, foo_get_foo (self));
+		break;
+		case FOO_MANAM_PROPERTY:
+		g_value_take_boxed (value, foo_get_manam (self));
+		break;
+		default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+		break;
+	}
+}
+
+static void
+_vala_foo_set_property (GObject * object,
+                        guint property_id,
+                        const GValue * value,
+                        GParamSpec * pspec)
+{
+	Foo * self;
+	self = G_TYPE_CHECK_INSTANCE_CAST (object, TYPE_FOO, Foo);
+	switch (property_id) {
+		case FOO_BAR_PROPERTY:
+		foo_set_bar (self, g_value_get_boxed (value));
+		break;
+		case FOO_FOO_PROPERTY:
+		foo_set_foo (self, g_value_get_boxed (value));
+		break;
+		case FOO_MANAM_PROPERTY:
+		foo_set_manam (self, g_value_get_boxed (value));
+		break;
+		default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+		break;
+	}
+}
+
+static void
+_vala_main (void)
+{
+	{
+		Bar* bar = NULL;
+		Bar* _tmp0_;
+		GError* _tmp1_;
+		GError* _tmp2_;
+		GError* _tmp3_;
+		GError* _tmp4_;
+		GError* _tmp5_;
+		GError* _tmp6_;
+		GError* _tmp7_;
+		GError* _tmp8_;
+		_tmp0_ = bar_new ();
+		bar = _tmp0_;
+		_tmp1_ = g_error_new_literal (FOO_ERROR, FOO_ERROR_BAD, "OOPS");
+		_tmp2_ = _tmp1_;
+		bar_set_foo (bar, _tmp2_);
+		_g_error_free0 (_tmp2_);
+		_tmp3_ = bar_get_foo (bar);
+		_tmp4_ = _tmp3_;
+		_vala_assert (_tmp4_->code == FOO_ERROR_BAD, "bar.foo.code == FooError.BAD");
+		_tmp5_ = g_error_new_literal (FOO_ERROR, FOO_ERROR_BAD, "OOPS");
+		_tmp6_ = _tmp5_;
+		bar_set_bar (bar, _tmp6_);
+		_g_error_free0 (_tmp6_);
+		_tmp7_ = bar_get_bar (bar);
+		_tmp8_ = _tmp7_;
+		_vala_assert (_tmp8_->code == FOO_ERROR_BAD, "bar.bar.code == FooError.BAD");
+		_bar_unref0 (bar);
+	}
+	{
+		Foo* foo = NULL;
+		Foo* _tmp9_;
+		GError* _tmp10_;
+		GError* _tmp11_;
+		GError* _tmp12_;
+		GError* _tmp13_;
+		GError* _tmp14_;
+		GError* _tmp15_;
+		GError* _tmp16_;
+		GError* _tmp17_;
+		GError* _tmp18_;
+		GError* _tmp19_;
+		GError* _tmp20_;
+		GError* _tmp21_;
+		GError* _tmp22_;
+		_tmp9_ = foo_new ();
+		foo = _tmp9_;
+		_tmp10_ = g_error_new_literal (FOO_ERROR, FOO_ERROR_BAD, "OOPS");
+		_tmp11_ = _tmp10_;
+		foo_set_foo (foo, _tmp11_);
+		_g_error_free0 (_tmp11_);
+		_tmp12_ = foo_get_foo (foo);
+		_tmp13_ = _tmp12_;
+		_vala_assert (_tmp13_->code == FOO_ERROR_BAD, "foo.foo.code == FooError.BAD");
+		_tmp14_ = g_error_new_literal (FOO_ERROR, FOO_ERROR_BAD, "OOPS");
+		_tmp15_ = _tmp14_;
+		foo_set_bar (foo, _tmp15_);
+		_g_error_free0 (_tmp15_);
+		_tmp16_ = foo_get_bar (foo);
+		_tmp17_ = _tmp16_;
+		_vala_assert (_tmp17_->code == FOO_ERROR_BAD, "foo.bar.code == FooError.BAD");
+		_tmp18_ = g_error_new_literal (FOO_ERROR, FOO_ERROR_BAD, "OOPS");
+		_tmp19_ = _tmp18_;
+		foo_set_manam (foo, _tmp19_);
+		_g_error_free0 (_tmp19_);
+		_tmp20_ = foo_get_manam (foo);
+		_tmp21_ = _tmp20_;
+		_tmp22_ = _tmp21_;
+		_vala_assert (_tmp22_->code == FOO_ERROR_BAD, "foo.manam.code == FooError.BAD");
+		_g_error_free0 (_tmp22_);
+		_g_object_unref0 (foo);
+	}
+}
+
+int
+main (int argc,
+      char ** argv)
+{
+	_vala_main ();
+	return 0;
+}
+
diff --git a/tests/objects/property-error.vala b/tests/objects/property-error.vala
new file mode 100644
index 000000000..8ce9b42db
--- /dev/null
+++ b/tests/objects/property-error.vala
@@ -0,0 +1,33 @@
+errordomain FooError {
+	BAD;
+}
+
+class Bar {
+	public Error bar { get; set; }
+	public FooError foo { get; set; }
+}
+
+class Foo : Object {
+	public Error bar { get; set; }
+	public FooError foo { get; set; }
+	public FooError manam { owned get; set; }
+}
+
+void main () {
+	{
+		var bar = new Bar ();
+		bar.foo = new FooError.BAD ("OOPS");
+		assert (bar.foo.code == FooError.BAD);
+		bar.bar = new FooError.BAD ("OOPS");
+		assert (bar.bar.code == FooError.BAD);
+	}
+	{
+		var foo = new Foo ();
+		foo.foo = new FooError.BAD ("OOPS");
+		assert (foo.foo.code == FooError.BAD);
+		foo.bar = new FooError.BAD ("OOPS");
+		assert (foo.bar.code == FooError.BAD);
+		foo.manam = new FooError.BAD ("OOPS");
+		assert (foo.manam.code == FooError.BAD);
+	}
+}
diff --git a/tests/objects/signals-error-marshal.c-expected b/tests/objects/signals-error-marshal.c-expected
index b34ee5e50..b7dd80eb1 100644
--- a/tests/objects/signals-error-marshal.c-expected
+++ b/tests/objects/signals-error-marshal.c-expected
@@ -39,6 +39,7 @@ static GParamSpec* foo_properties[FOO_NUM_PROPERTIES];
 enum  {
 	FOO_FOO_SIGNAL,
 	FOO_BAR_SIGNAL,
+	FOO_BAZ_SIGNAL,
 	FOO_NUM_SIGNALS
 };
 static guint foo_signals[FOO_NUM_SIGNALS] = {0};
@@ -84,18 +85,19 @@ static void _foo_callback_foo_bar (Foo* _sender,
                             void* p,
                             GError* e,
                             gpointer self);
+static void foo_callback2 (Foo* self,
+                    void* p,
+                    GError* e);
+static void _foo_callback2_foo_baz (Foo* _sender,
+                             void* p,
+                             GError* e,
+                             gpointer self);
 static void g_cclosure_user_marshal_VOID__POINTER_BOXED (GClosure * closure,
                                                   GValue * return_value,
                                                   guint n_param_values,
                                                   const GValue * param_values,
                                                   gpointer invocation_hint,
                                                   gpointer marshal_data);
-static void g_cclosure_user_marshal_VOID__POINTER_POINTER (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);
 static void _vala_main (void);
 
@@ -170,18 +172,34 @@ _foo_callback_foo_bar (Foo* _sender,
 	foo_callback ((Foo*) self, p, e);
 }
 
+static void
+_foo_callback2_foo_baz (Foo* _sender,
+                        void* p,
+                        GError* e,
+                        gpointer self)
+{
+	foo_callback2 ((Foo*) self, p, e);
+}
+
 Foo*
 foo_construct (GType object_type)
 {
 	Foo * self = NULL;
 	GError* _tmp0_;
 	GError* _tmp1_;
+	GError* _tmp2_;
+	GError* _tmp3_;
 	self = (Foo*) g_object_new (object_type, NULL);
 	g_signal_connect_object (self, "bar", (GCallback) _foo_callback_foo_bar, self, 0);
 	_tmp0_ = g_error_new_literal (FOO_ERROR, FOO_ERROR_BAD, "bad");
 	_tmp1_ = _tmp0_;
 	g_signal_emit (self, foo_signals[FOO_BAR_SIGNAL], 0, NULL, _tmp1_);
 	_g_error_free0 (_tmp1_);
+	g_signal_connect_object (self, "baz", (GCallback) _foo_callback2_foo_baz, self, 0);
+	_tmp2_ = g_error_new_literal (FOO_ERROR, FOO_ERROR_BAD, "bad");
+	_tmp3_ = _tmp2_;
+	g_signal_emit (self, foo_signals[FOO_BAZ_SIGNAL], 0, NULL, _tmp3_);
+	_g_error_free0 (_tmp3_);
 	return self;
 }
 
@@ -203,6 +221,16 @@ foo_callback (Foo* self,
 }
 
 static void
+foo_callback2 (Foo* self,
+               void* p,
+               GError* e)
+{
+	g_return_if_fail (IS_FOO (self));
+	_vala_assert (p == NULL, "p == null");
+	_vala_assert (e->code == FOO_ERROR_BAD, "e.code == FooError.BAD");
+}
+
+static void
 g_cclosure_user_marshal_VOID__POINTER_BOXED (GClosure * closure,
                                              GValue * return_value,
                                              guint n_param_values,
@@ -229,38 +257,13 @@ g_cclosure_user_marshal_VOID__POINTER_BOXED (GClosure * closure,
 }
 
 static void
-g_cclosure_user_marshal_VOID__POINTER_POINTER (GClosure * closure,
-                                               GValue * return_value,
-                                               guint n_param_values,
-                                               const GValue * param_values,
-                                               gpointer invocation_hint,
-                                               gpointer marshal_data)
-{
-	typedef void (*GMarshalFunc_VOID__POINTER_POINTER) (gpointer data1, gpointer arg_1, gpointer arg_2, gpointer data2);
-	register GMarshalFunc_VOID__POINTER_POINTER callback;
-	register GCClosure * cc;
-	register gpointer data1;
-	register gpointer data2;
-	cc = (GCClosure *) closure;
-	g_return_if_fail (n_param_values == 3);
-	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_VOID__POINTER_POINTER) (marshal_data ? marshal_data : cc->callback);
-	callback (data1, g_value_get_pointer (param_values + 1), g_value_get_pointer (param_values + 2), data2);
-}
-
-static void
 foo_class_init (FooClass * klass,
                 gpointer klass_data)
 {
 	foo_parent_class = g_type_class_peek_parent (klass);
 	foo_signals[FOO_FOO_SIGNAL] = g_signal_new ("foo", TYPE_FOO, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__POINTER_BOXED, G_TYPE_NONE, 2, G_TYPE_POINTER, TYPE_BAR);
-	foo_signals[FOO_BAR_SIGNAL] = g_signal_new ("bar", TYPE_FOO, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__POINTER_POINTER, G_TYPE_NONE, 2, G_TYPE_POINTER, G_TYPE_POINTER);
+	foo_signals[FOO_BAR_SIGNAL] = g_signal_new ("bar", TYPE_FOO, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__POINTER_BOXED, G_TYPE_NONE, 2, G_TYPE_POINTER, G_TYPE_ERROR);
+	foo_signals[FOO_BAZ_SIGNAL] = g_signal_new ("baz", TYPE_FOO, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__POINTER_BOXED, G_TYPE_NONE, 2, G_TYPE_POINTER, G_TYPE_ERROR);
 }
 
 static void
diff --git a/tests/objects/signals-error-marshal.vala b/tests/objects/signals-error-marshal.vala
index b727777e2..39c24df2c 100644
--- a/tests/objects/signals-error-marshal.vala
+++ b/tests/objects/signals-error-marshal.vala
@@ -9,16 +9,25 @@ struct Bar {
 class Foo : GLib.Object {
 	signal void foo (void* p, Bar bar);
 	signal void bar (void* p, Error e);
+	signal void baz (void* p, FooError e);
 
 	public Foo () {
 		bar.connect (callback);
 		bar (null, new FooError.BAD ("bad"));
+
+		baz.connect (callback2);
+		baz (null, new FooError.BAD ("bad"));
 	}
 
 	void callback (void* p, Error e) {
 		assert (p == null);
 		assert (e.code == FooError.BAD);
 	}
+
+	void callback2 (void* p, FooError e) {
+		assert (p == null);
+		assert (e.code == FooError.BAD);
+	}
 }
 
 void main() {