From: Rico Tzschichholz Date: Thu, 10 Feb 2022 17:07:56 +0000 (+0100) Subject: vala: Catch and throw possible inner error of lock statements X-Git-Tag: 0.55.90~26 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=d9f702289b4b39683d0c9361e1ea02fd51ecae22;p=thirdparty%2Fvala.git vala: Catch and throw possible inner error of lock statements See 40c1dbfbfedb6c4a6b88df045eb1c2e7bdd38d93 Fixes https://gitlab.gnome.org/GNOME/vala/issues/83 --- diff --git a/tests/Makefile.am b/tests/Makefile.am index b70914b67..05bf52d1d 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -283,6 +283,7 @@ TESTS = \ control-flow/gptrarray-foreach-variable.test \ control-flow/gsequence-foreach-variable.test \ control-flow/local-clash-with-implicit-this.vala \ + control-flow/lock-if-throw.vala \ control-flow/missing-break.test \ control-flow/missing-return.test \ control-flow/nested-conditional.vala \ diff --git a/tests/control-flow/lock-if-throw.c-expected b/tests/control-flow/lock-if-throw.c-expected new file mode 100644 index 000000000..ee259cffc --- /dev/null +++ b/tests/control-flow/lock-if-throw.c-expected @@ -0,0 +1,372 @@ +/* control_flow_lock_if_throw.c generated by valac, the Vala compiler + * generated from control_flow_lock_if_throw.vala, do not modify */ + +#include +#include +#include + +#if !defined(VALA_EXTERN) +#if defined(_MSC_VER) +#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 struct _FooPrivate FooPrivate; +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) +typedef struct _ParamSpecFoo ParamSpecFoo; + +typedef enum { + FOO_ERROR_FAIL +} FooError; +#define FOO_ERROR foo_error_quark () +struct _Foo { + GTypeInstance parent_instance; + volatile int ref_count; + FooPrivate * priv; +}; + +struct _FooClass { + GTypeClass parent_class; + void (*finalize) (Foo *self); +}; + +struct _FooPrivate { + gboolean manam; + GRecMutex __lock_manam; +}; + +struct _ParamSpecFoo { + GParamSpec parent_instance; +}; + +static gint Foo_private_offset; +static gpointer foo_parent_class = NULL; + +VALA_EXTERN GQuark foo_error_quark (void); +VALA_EXTERN gpointer foo_ref (gpointer instance); +VALA_EXTERN void foo_unref (gpointer instance); +VALA_EXTERN GParamSpec* param_spec_foo (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags); +VALA_EXTERN void value_set_foo (GValue* value, + gpointer v_object); +VALA_EXTERN void value_take_foo (GValue* value, + gpointer v_object); +VALA_EXTERN gpointer value_get_foo (const GValue* value); +VALA_EXTERN GType foo_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Foo, foo_unref) +VALA_EXTERN gboolean foo_bar (Foo* self, + GError** error); +VALA_EXTERN Foo* foo_new (void); +VALA_EXTERN Foo* foo_construct (GType object_type); +static void foo_finalize (Foo * obj); +static GType foo_get_type_once (void); +static void _vala_main (void); + +GQuark +foo_error_quark (void) +{ + return g_quark_from_static_string ("foo-error-quark"); +} + +static inline gpointer +foo_get_instance_private (Foo* self) +{ + return G_STRUCT_MEMBER_P (self, Foo_private_offset); +} + +gboolean +foo_bar (Foo* self, + GError** error) +{ + gboolean _result_ = FALSE; + GError* _inner_error0_ = NULL; + gboolean result; + g_return_val_if_fail (IS_FOO (self), FALSE); + { + g_rec_mutex_lock (&self->priv->__lock_manam); + { + if (self->priv->manam) { + GError* _tmp0_; + _tmp0_ = g_error_new_literal (FOO_ERROR, FOO_ERROR_FAIL, "foo"); + _inner_error0_ = _tmp0_; + goto __catch0_g_error; + } else { + _result_ = TRUE; + } + } + goto __finally0; + __catch0_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp1_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp1_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp1_; + _g_error_free0 (_lock_error_); + goto __finally0; + } + __finally0: + { + GError* _inner_error1_ = NULL; + g_rec_mutex_unlock (&self->priv->__lock_manam); + } + if (G_UNLIKELY (_inner_error0_ != NULL)) { + gboolean _tmp2_ = FALSE; + g_propagate_error (error, _inner_error0_); + return _tmp2_; + } + } + result = _result_; + return result; +} + +Foo* +foo_construct (GType object_type) +{ + Foo* self = NULL; + self = (Foo*) g_type_create_instance (object_type); + return self; +} + +Foo* +foo_new (void) +{ + return foo_construct (TYPE_FOO); +} + +static void +value_foo_init (GValue* value) +{ + value->data[0].v_pointer = NULL; +} + +static void +value_foo_free_value (GValue* value) +{ + if (value->data[0].v_pointer) { + foo_unref (value->data[0].v_pointer); + } +} + +static void +value_foo_copy_value (const GValue* src_value, + GValue* dest_value) +{ + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = foo_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + +static gpointer +value_foo_peek_pointer (const GValue* value) +{ + return value->data[0].v_pointer; +} + +static gchar* +value_foo_collect_value (GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + if (collect_values[0].v_pointer) { + Foo * 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 = foo_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + +static gchar* +value_foo_lcopy_value (const GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + Foo ** 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 = foo_ref (value->data[0].v_pointer); + } + return NULL; +} + +GParamSpec* +param_spec_foo (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags) +{ + ParamSpecFoo* spec; + g_return_val_if_fail (g_type_is_a (object_type, TYPE_FOO), 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_foo (const GValue* value) +{ + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_FOO), NULL); + return value->data[0].v_pointer; +} + +void +value_set_foo (GValue* value, + gpointer v_object) +{ + Foo * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_FOO)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_FOO)); + 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; + foo_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + foo_unref (old); + } +} + +void +value_take_foo (GValue* value, + gpointer v_object) +{ + Foo * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_FOO)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_FOO)); + 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) { + foo_unref (old); + } +} + +static void +foo_class_init (FooClass * klass, + gpointer klass_data) +{ + foo_parent_class = g_type_class_peek_parent (klass); + ((FooClass *) klass)->finalize = foo_finalize; + g_type_class_adjust_private_offset (klass, &Foo_private_offset); +} + +static void +foo_instance_init (Foo * self, + gpointer klass) +{ + self->priv = foo_get_instance_private (self); + g_rec_mutex_init (&self->priv->__lock_manam); + self->priv->manam = TRUE; + self->ref_count = 1; +} + +static void +foo_finalize (Foo * obj) +{ + Foo * self; + self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_FOO, Foo); + g_signal_handlers_destroy (self); + g_rec_mutex_clear (&self->priv->__lock_manam); +} + +static GType +foo_get_type_once (void) +{ + static const GTypeValueTable g_define_type_value_table = { value_foo_init, value_foo_free_value, value_foo_copy_value, value_foo_peek_pointer, "p", value_foo_collect_value, "p", value_foo_lcopy_value }; + 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, &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 foo_type_id; + foo_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Foo", &g_define_type_info, &g_define_type_fundamental_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; +} + +gpointer +foo_ref (gpointer instance) +{ + Foo * self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + +void +foo_unref (gpointer instance) +{ + Foo * self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + FOO_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + +static void +_vala_main (void) +{ +} + +int +main (int argc, + char ** argv) +{ + _vala_main (); + return 0; +} + diff --git a/tests/control-flow/lock-if-throw.vala b/tests/control-flow/lock-if-throw.vala new file mode 100644 index 000000000..22747c560 --- /dev/null +++ b/tests/control-flow/lock-if-throw.vala @@ -0,0 +1,24 @@ +errordomain FooError { + FAIL; +} + +class Foo { + bool manam = true; + + public bool bar () throws Error { + bool result; + + lock (manam) { + if (manam) { + throw new FooError.FAIL ("foo"); + } else { + result = true; + } + } + + return result; + } +} + +void main () { +} diff --git a/tests/objects/bug629593.c-expected b/tests/objects/bug629593.c-expected index 4f4814f01..bc99f4037 100644 --- a/tests/objects/bug629593.c-expected +++ b/tests/objects/bug629593.c-expected @@ -25,6 +25,7 @@ typedef struct _Foo Foo; typedef struct _FooClass FooClass; typedef struct _FooPrivate FooPrivate; +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) typedef struct _ParamSpecFoo ParamSpecFoo; #define TYPE_BAR (bar_get_type ()) @@ -158,6 +159,19 @@ foo_run (Foo* self) { self->other_variable = 1; } + goto __finally0; + __catch0_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp0_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp0_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp0_; + _g_error_free0 (_lock_error_); + goto __finally0; + } __finally0: { g_rec_mutex_unlock (&self->priv->__lock_thing_to_lock_on); @@ -399,6 +413,19 @@ bar_run (Bar* self) { self->other_variable = 1; } + goto __finally0; + __catch0_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp0_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp0_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp0_; + _g_error_free0 (_lock_error_); + goto __finally0; + } __finally0: { g_rec_mutex_unlock (&BAR_GET_CLASS_PRIVATE (BAR_GET_CLASS (self))->__lock_thing_to_lock_on); diff --git a/tests/objects/bug795521.c-expected b/tests/objects/bug795521.c-expected index 07a627494..a4d39a55c 100644 --- a/tests/objects/bug795521.c-expected +++ b/tests/objects/bug795521.c-expected @@ -26,6 +26,7 @@ typedef struct _Foo Foo; typedef struct _FooClass FooClass; typedef struct _FooPrivate FooPrivate; typedef struct _FooClassPrivate FooClassPrivate; +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) typedef struct _ParamSpecFoo ParamSpecFoo; struct _Foo { @@ -108,6 +109,19 @@ foo_use (Foo* self) g_rec_mutex_lock (&self->priv->__lock_faz); { } + goto __finally0; + __catch0_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp0_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp0_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp0_; + _g_error_free0 (_lock_error_); + goto __finally0; + } __finally0: { g_rec_mutex_unlock (&self->priv->__lock_faz); @@ -122,6 +136,19 @@ foo_use (Foo* self) g_rec_mutex_lock (&FOO_GET_CLASS_PRIVATE (FOO_GET_CLASS (self))->__lock_baz); { } + goto __finally1; + __catch1_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp1_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp1_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp1_; + _g_error_free0 (_lock_error_); + goto __finally1; + } __finally1: { g_rec_mutex_unlock (&FOO_GET_CLASS_PRIVATE (FOO_GET_CLASS (self))->__lock_baz); @@ -136,6 +163,19 @@ foo_use (Foo* self) g_rec_mutex_lock (&__lock_foo_maz); { } + goto __finally2; + __catch2_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp2_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp2_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp2_; + _g_error_free0 (_lock_error_); + goto __finally2; + } __finally2: { g_rec_mutex_unlock (&__lock_foo_maz); @@ -150,6 +190,19 @@ foo_use (Foo* self) g_rec_mutex_lock (&self->priv->__lock_foor); { } + goto __finally3; + __catch3_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp3_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp3_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp3_; + _g_error_free0 (_lock_error_); + goto __finally3; + } __finally3: { g_rec_mutex_unlock (&self->priv->__lock_foor); @@ -164,6 +217,19 @@ foo_use (Foo* self) g_rec_mutex_lock (&FOO_GET_CLASS_PRIVATE (FOO_GET_CLASS (self))->__lock_boor); { } + goto __finally4; + __catch4_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp4_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp4_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp4_; + _g_error_free0 (_lock_error_); + goto __finally4; + } __finally4: { g_rec_mutex_unlock (&FOO_GET_CLASS_PRIVATE (FOO_GET_CLASS (self))->__lock_boor); @@ -178,6 +244,19 @@ foo_use (Foo* self) g_rec_mutex_lock (&__lock_foo_foo_moor); { } + goto __finally5; + __catch5_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp5_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp5_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp5_; + _g_error_free0 (_lock_error_); + goto __finally5; + } __finally5: { g_rec_mutex_unlock (&__lock_foo_foo_moor); @@ -189,15 +268,28 @@ foo_use (Foo* self) } } { - gint _tmp0_; - _tmp0_ = self->priv->_foop; + gint _tmp6_; + _tmp6_ = self->priv->_foop; g_rec_mutex_lock (&self->priv->__lock_foop); { } + goto __finally6; + __catch6_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp7_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp7_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp7_; + _g_error_free0 (_lock_error_); + goto __finally6; + } __finally6: { - gint _tmp1_; - _tmp1_ = self->priv->_foop; + gint _tmp8_; + _tmp8_ = self->priv->_foop; g_rec_mutex_unlock (&self->priv->__lock_foop); } if (G_UNLIKELY (_inner_error0_ != NULL)) { diff --git a/tests/objects/fields.c-expected b/tests/objects/fields.c-expected index c0fdf2f7c..d96e92721 100644 --- a/tests/objects/fields.c-expected +++ b/tests/objects/fields.c-expected @@ -40,6 +40,7 @@ typedef struct _Faz Faz; typedef struct _FazClass FazClass; typedef struct _FazPrivate FazPrivate; typedef struct _FazClassPrivate FazClassPrivate; +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) #define TYPE_BAR (bar_get_type ()) #define BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_BAR, Bar)) @@ -577,6 +578,19 @@ faz_lock_action (Faz* self) faz_private_static_field = 1147; _vala_assert (faz_private_static_field == 1147, "private_static_field == 1147"); } + goto __finally0; + __catch0_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp0_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp0_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp0_; + _g_error_free0 (_lock_error_); + goto __finally0; + } __finally0: { g_rec_mutex_unlock (&__lock_faz_faz_private_static_field); @@ -593,6 +607,19 @@ faz_lock_action (Faz* self) faz_public_static_field = 1147; _vala_assert (faz_public_static_field == 1147, "public_static_field == 1147"); } + goto __finally1; + __catch1_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp1_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp1_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp1_; + _g_error_free0 (_lock_error_); + goto __finally1; + } __finally1: { g_rec_mutex_unlock (&__lock_faz_faz_public_static_field); @@ -609,6 +636,19 @@ faz_lock_action (Faz* self) self->priv->private_field = 1147; _vala_assert (self->priv->private_field == 1147, "private_field == 1147"); } + goto __finally2; + __catch2_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp2_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp2_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp2_; + _g_error_free0 (_lock_error_); + goto __finally2; + } __finally2: { g_rec_mutex_unlock (&self->priv->__lock_private_field); @@ -625,6 +665,19 @@ faz_lock_action (Faz* self) self->public_field = 1147; _vala_assert (self->public_field == 1147, "public_field == 1147"); } + goto __finally3; + __catch3_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp3_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp3_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp3_; + _g_error_free0 (_lock_error_); + goto __finally3; + } __finally3: { g_rec_mutex_unlock (&self->priv->__lock_public_field); @@ -648,6 +701,19 @@ faz_lock_action_class (Faz* self) FAZ_GET_CLASS_PRIVATE (FAZ_GET_CLASS (self))->private_class_field = 1147; _vala_assert (FAZ_GET_CLASS_PRIVATE (FAZ_GET_CLASS (self))->private_class_field == 1147, "private_class_field == 1147"); } + goto __finally0; + __catch0_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp0_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp0_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp0_; + _g_error_free0 (_lock_error_); + goto __finally0; + } __finally0: { g_rec_mutex_unlock (&FAZ_GET_CLASS_PRIVATE (FAZ_GET_CLASS (self))->__lock_private_class_field); @@ -664,6 +730,19 @@ faz_lock_action_class (Faz* self) FAZ_GET_CLASS (self)->public_class_field = 1147; _vala_assert (FAZ_GET_CLASS (self)->public_class_field == 1147, "public_class_field == 1147"); } + goto __finally1; + __catch1_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp1_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp1_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp1_; + _g_error_free0 (_lock_error_); + goto __finally1; + } __finally1: { g_rec_mutex_unlock (&FAZ_GET_CLASS_PRIVATE (FAZ_GET_CLASS (self))->__lock_public_class_field); @@ -882,6 +961,19 @@ baz_lock_action (Baz* self) baz_private_static_field = 1147; _vala_assert (baz_private_static_field == 1147, "private_static_field == 1147"); } + goto __finally0; + __catch0_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp0_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp0_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp0_; + _g_error_free0 (_lock_error_); + goto __finally0; + } __finally0: { g_rec_mutex_unlock (&__lock_baz_baz_private_static_field); @@ -898,6 +990,19 @@ baz_lock_action (Baz* self) baz_public_static_field = 1147; _vala_assert (baz_public_static_field == 1147, "public_static_field == 1147"); } + goto __finally1; + __catch1_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp1_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp1_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp1_; + _g_error_free0 (_lock_error_); + goto __finally1; + } __finally1: { g_rec_mutex_unlock (&__lock_baz_baz_public_static_field); @@ -914,6 +1019,19 @@ baz_lock_action (Baz* self) self->priv->private_field = 1147; _vala_assert (self->priv->private_field == 1147, "private_field == 1147"); } + goto __finally2; + __catch2_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp2_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp2_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp2_; + _g_error_free0 (_lock_error_); + goto __finally2; + } __finally2: { g_rec_mutex_unlock (&self->priv->__lock_private_field); @@ -930,6 +1048,19 @@ baz_lock_action (Baz* self) self->public_field = 1147; _vala_assert (self->public_field == 1147, "public_field == 1147"); } + goto __finally3; + __catch3_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp3_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp3_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp3_; + _g_error_free0 (_lock_error_); + goto __finally3; + } __finally3: { g_rec_mutex_unlock (&self->priv->__lock_public_field); @@ -953,6 +1084,19 @@ baz_lock_action_class (Baz* self) BAZ_GET_CLASS_PRIVATE (BAZ_GET_CLASS (self))->private_class_field = 1147; _vala_assert (BAZ_GET_CLASS_PRIVATE (BAZ_GET_CLASS (self))->private_class_field == 1147, "private_class_field == 1147"); } + goto __finally0; + __catch0_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp0_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp0_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp0_; + _g_error_free0 (_lock_error_); + goto __finally0; + } __finally0: { g_rec_mutex_unlock (&BAZ_GET_CLASS_PRIVATE (BAZ_GET_CLASS (self))->__lock_private_class_field); @@ -969,6 +1113,19 @@ baz_lock_action_class (Baz* self) BAZ_GET_CLASS (self)->public_class_field = 1147; _vala_assert (BAZ_GET_CLASS (self)->public_class_field == 1147, "public_class_field == 1147"); } + goto __finally1; + __catch1_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp1_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp1_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp1_; + _g_error_free0 (_lock_error_); + goto __finally1; + } __finally1: { g_rec_mutex_unlock (&BAZ_GET_CLASS_PRIVATE (BAZ_GET_CLASS (self))->__lock_public_class_field); diff --git a/tests/objects/properties.c-expected b/tests/objects/properties.c-expected index 7e0785610..b8121f1dd 100644 --- a/tests/objects/properties.c-expected +++ b/tests/objects/properties.c-expected @@ -60,6 +60,7 @@ enum { }; static GParamSpec* sample_properties[SAMPLE_NUM_PROPERTIES]; #define _g_free0(var) (var = (g_free (var), NULL)) +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) #define MAMAN_TYPE_IBAZ (maman_ibaz_get_type ()) #define MAMAN_IBAZ(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAMAN_TYPE_IBAZ, MamanIbaz)) @@ -780,10 +781,23 @@ sample_run (Sample* self) { sample_set_public_prop (self, 42); } + goto __finally0; + __catch0_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp11_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp11_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp11_; + _g_error_free0 (_lock_error_); + goto __finally0; + } __finally0: { - gint _tmp11_; - _tmp11_ = self->priv->_public_prop; + gint _tmp12_; + _tmp12_ = self->priv->_public_prop; g_rec_mutex_unlock (&self->priv->__lock_public_prop); } if (G_UNLIKELY (_inner_error0_ != NULL)) { @@ -793,16 +807,29 @@ sample_run (Sample* self) } } { - gint _tmp12_; - _tmp12_ = self->priv->_private_prop; + gint _tmp13_; + _tmp13_ = self->priv->_private_prop; g_rec_mutex_lock (&self->priv->__lock_private_prop); { sample_set_private_prop (self, 42); } + goto __finally1; + __catch1_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp14_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp14_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp14_; + _g_error_free0 (_lock_error_); + goto __finally1; + } __finally1: { - gint _tmp13_; - _tmp13_ = self->priv->_private_prop; + gint _tmp15_; + _tmp15_ = self->priv->_private_prop; g_rec_mutex_unlock (&self->priv->__lock_private_prop); } if (G_UNLIKELY (_inner_error0_ != NULL)) { diff --git a/tests/parser/lock-statement.c-expected b/tests/parser/lock-statement.c-expected index 6deb21ef3..9d0ea89d7 100644 --- a/tests/parser/lock-statement.c-expected +++ b/tests/parser/lock-statement.c-expected @@ -25,6 +25,7 @@ typedef struct _Foo Foo; typedef struct _FooClass FooClass; typedef struct _FooPrivate FooPrivate; +#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL))) typedef struct _ParamSpecFoo ParamSpecFoo; struct _Foo { @@ -95,6 +96,19 @@ foo_implicit_unlocking (Foo* self) g_rec_mutex_lock (&self->priv->__lock_lockable); { } + goto __finally0; + __catch0_g_error: + { + GError* _lock_error_ = NULL; + GError* _tmp0_; + _lock_error_ = _inner_error0_; + _inner_error0_ = NULL; + _tmp0_ = _lock_error_; + _lock_error_ = NULL; + _inner_error0_ = _tmp0_; + _g_error_free0 (_lock_error_); + goto __finally0; + } __finally0: { g_rec_mutex_unlock (&self->priv->__lock_lockable); diff --git a/vala/valalockstatement.vala b/vala/valalockstatement.vala index 65c579be6..1035e9efc 100644 --- a/vala/valalockstatement.vala +++ b/vala/valalockstatement.vala @@ -89,9 +89,17 @@ public class Vala.LockStatement : CodeNode, Statement { var fin_body = new Block (source_reference); fin_body.add_statement (new UnlockStatement (resource, source_reference)); + var catch_body = new Block (source_reference); + catch_body.add_statement (new ThrowStatement (new ReferenceTransferExpression (new MemberAccess.simple ("_lock_error_")), source_reference)); + var catch_clause = new CatchClause (new ErrorType (null, null), "_lock_error_", catch_body, source_reference); + catch_clause.error_type.value_owned = true; + + var try_stmt = new TryStatement (body, fin_body, source_reference); + try_stmt.add_catch_clause (catch_clause); + var block = new Block (source_reference); block.add_statement (new LockStatement (resource, null, source_reference)); - block.add_statement (new TryStatement (body, fin_body, source_reference)); + block.add_statement (try_stmt); var parent_block = (Block) parent_node; parent_block.replace_statement (this, block);