From: Rico Tzschichholz Date: Mon, 31 Jan 2022 15:37:44 +0000 (+0100) Subject: codegen: Use correct target/destroy of delegate field initializer X-Git-Tag: 0.54.7~14 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=3f13ad3d40e371bab078f1145f0e634542dbc602;p=thirdparty%2Fvala.git codegen: Use correct target/destroy of delegate field initializer Fixes https://gitlab.gnome.org/GNOME/vala/issues/1285 --- diff --git a/codegen/valaccodebasemodule.vala b/codegen/valaccodebasemodule.vala index aca848020..6997e1794 100644 --- a/codegen/valaccodebasemodule.vala +++ b/codegen/valaccodebasemodule.vala @@ -1321,10 +1321,19 @@ public abstract class Vala.CCodeBaseModule : CodeGenerator { var delegate_type = (DelegateType) f.variable_type; if (delegate_type.delegate_symbol.has_target) { var field_value = get_field_cvalue (f, load_this_parameter ((TypeSymbol) f.parent_symbol)); - - ccode.add_assignment (get_delegate_target_cvalue (field_value), new CCodeIdentifier ("self")); + var target_cvalue = get_delegate_target_cvalue (f.initializer.target_value); + if (target_cvalue != null) { + ccode.add_assignment (get_delegate_target_cvalue (field_value), target_cvalue); + } else { + ccode.add_assignment (get_delegate_target_cvalue (field_value), new CCodeIdentifier ("self")); + } if (delegate_type.is_disposable ()) { - ccode.add_assignment (get_delegate_target_destroy_notify_cvalue (field_value), new CCodeConstant ("NULL")); + var destroy_cvalue = get_delegate_target_destroy_notify_cvalue (f.initializer.target_value); + if (destroy_cvalue != null) { + ccode.add_assignment (get_delegate_target_destroy_notify_cvalue (field_value), destroy_cvalue); + } else { + ccode.add_assignment (get_delegate_target_destroy_notify_cvalue (field_value), new CCodeConstant ("NULL")); + } } } } diff --git a/tests/Makefile.am b/tests/Makefile.am index 8e448986f..82cde888e 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -415,6 +415,7 @@ TESTS = \ structs/bug777194.vala \ structs/bug777194-2.vala \ delegates/casting.vala \ + delegates/class-field-initializer.vala \ delegates/compatible.vala \ delegates/delegate_only.vala \ delegates/delegate-recusive.vala \ diff --git a/tests/delegates/class-field-initializer.c-expected b/tests/delegates/class-field-initializer.c-expected new file mode 100644 index 000000000..b67e73567 --- /dev/null +++ b/tests/delegates/class-field-initializer.c-expected @@ -0,0 +1,466 @@ +/* delegates_class_field_initializer.c generated by valac, the Vala compiler + * generated from delegates_class_field_initializer.vala, do not modify */ + +#include +#include +#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 + +typedef gchar* (*FooFunc) (gpointer user_data); +typedef struct _Block1Data Block1Data; +#define _g_free0(var) (var = (g_free (var), NULL)) + +#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; +typedef struct _ParamSpecFoo ParamSpecFoo; +typedef struct _Bar Bar; +#define _foo_unref0(var) ((var == NULL) ? NULL : (var = (foo_unref (var), NULL))) +#define _bar_free0(var) ((var == NULL) ? NULL : (var = (bar_free (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 _Block1Data { + int _ref_count_; + gchar* s; +}; + +struct _Foo { + GTypeInstance parent_instance; + volatile int ref_count; + FooPrivate * priv; + FooFunc func; + gpointer func_target; + GDestroyNotify func_target_destroy_notify; +}; + +struct _FooClass { + GTypeClass parent_class; + void (*finalize) (Foo *self); +}; + +struct _ParamSpecFoo { + GParamSpec parent_instance; +}; + +struct _Bar { + FooFunc func; + gpointer func_target; + GDestroyNotify func_target_destroy_notify; +}; + +static gpointer foo_parent_class = NULL; + +VALA_EXTERN FooFunc get_func (gpointer* result_target, + GDestroyNotify* result_target_destroy_notify); +static Block1Data* block1_data_ref (Block1Data* _data1_); +static void block1_data_unref (void * _userdata_); +static gchar* __lambda4_ (Block1Data* _data1_); +static gchar* ___lambda4__foo_func (gpointer self); +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 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); +VALA_EXTERN void bar_free (Bar * self); +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Bar, bar_free) +static void bar_instance_init (Bar * self); +VALA_EXTERN Bar* bar_new (void); +static void _vala_main (void); + +static Block1Data* +block1_data_ref (Block1Data* _data1_) +{ + g_atomic_int_inc (&_data1_->_ref_count_); + return _data1_; +} + +static void +block1_data_unref (void * _userdata_) +{ + Block1Data* _data1_; + _data1_ = (Block1Data*) _userdata_; + if (g_atomic_int_dec_and_test (&_data1_->_ref_count_)) { + _g_free0 (_data1_->s); + g_slice_free (Block1Data, _data1_); + } +} + +static gchar* +__lambda4_ (Block1Data* _data1_) +{ + gchar* _tmp0_; + gchar* result = NULL; + _tmp0_ = g_strdup (_data1_->s); + result = _tmp0_; + return result; +} + +static gchar* +___lambda4__foo_func (gpointer self) +{ + gchar* result; + result = __lambda4_ (self); + return result; +} + +FooFunc +get_func (gpointer* result_target, + GDestroyNotify* result_target_destroy_notify) +{ + Block1Data* _data1_; + gchar* _tmp0_; + FooFunc _tmp1_; + gpointer _tmp1__target; + GDestroyNotify _tmp1__target_destroy_notify; + FooFunc result = NULL; + _data1_ = g_slice_new0 (Block1Data); + _data1_->_ref_count_ = 1; + _tmp0_ = g_strdup ("foo"); + _data1_->s = _tmp0_; + _tmp1_ = ___lambda4__foo_func; + _tmp1__target = block1_data_ref (_data1_); + _tmp1__target_destroy_notify = block1_data_unref; + *result_target = _tmp1__target; + *result_target_destroy_notify = _tmp1__target_destroy_notify; + result = _tmp1_; + block1_data_unref (_data1_); + _data1_ = NULL; + 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; +} + +static void +foo_instance_init (Foo * self, + gpointer klass) +{ + gpointer _tmp0_ = NULL; + GDestroyNotify _tmp1_ = NULL; + FooFunc _tmp2_; + _tmp2_ = get_func (&_tmp0_, &_tmp1_); + self->func = _tmp2_; + self->func_target = _tmp0_; + self->func_target_destroy_notify = _tmp1_; + 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); + (self->func_target_destroy_notify == NULL) ? NULL : (self->func_target_destroy_notify (self->func_target), NULL); + self->func = NULL; + self->func_target = NULL; + self->func_target_destroy_notify = NULL; +} + +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); + return foo_type_id; +} + +GType +foo_get_type (void) +{ + static volatile gsize foo_type_id__volatile = 0; + if (g_once_init_enter (&foo_type_id__volatile)) { + GType foo_type_id; + foo_type_id = foo_get_type_once (); + g_once_init_leave (&foo_type_id__volatile, foo_type_id); + } + return foo_type_id__volatile; +} + +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); + } +} + +Bar* +bar_new (void) +{ + Bar* self; + self = g_slice_new0 (Bar); + bar_instance_init (self); + return self; +} + +static void +bar_instance_init (Bar * self) +{ + gpointer _tmp0_ = NULL; + GDestroyNotify _tmp1_ = NULL; + FooFunc _tmp2_; + _tmp2_ = get_func (&_tmp0_, &_tmp1_); + self->func = _tmp2_; + self->func_target = _tmp0_; + self->func_target_destroy_notify = _tmp1_; +} + +void +bar_free (Bar * self) +{ + (self->func_target_destroy_notify == NULL) ? NULL : (self->func_target_destroy_notify (self->func_target), NULL); + self->func = NULL; + self->func_target = NULL; + self->func_target_destroy_notify = NULL; + g_slice_free (Bar, self); +} + +static void +_vala_main (void) +{ + { + Foo* foo = NULL; + Foo* _tmp0_; + FooFunc _tmp1_; + gpointer _tmp1__target; + gchar* _tmp2_; + gchar* _tmp3_; + _tmp0_ = foo_new (); + foo = _tmp0_; + _tmp1_ = foo->func; + _tmp1__target = foo->func_target; + _tmp2_ = _tmp1_ (_tmp1__target); + _tmp3_ = _tmp2_; + _vala_assert (g_strcmp0 (_tmp3_, "foo") == 0, "foo.func () == \"foo\""); + _g_free0 (_tmp3_); + _foo_unref0 (foo); + } + { + Bar* bar = NULL; + Bar* _tmp4_; + FooFunc _tmp5_; + gpointer _tmp5__target; + gchar* _tmp6_; + gchar* _tmp7_; + _tmp4_ = bar_new (); + bar = _tmp4_; + _tmp5_ = bar->func; + _tmp5__target = bar->func_target; + _tmp6_ = _tmp5_ (_tmp5__target); + _tmp7_ = _tmp6_; + _vala_assert (g_strcmp0 (_tmp7_, "foo") == 0, "bar.func () == \"foo\""); + _g_free0 (_tmp7_); + _bar_free0 (bar); + } +} + +int +main (int argc, + char ** argv) +{ + _vala_main (); + return 0; +} + diff --git a/tests/delegates/class-field-initializer.vala b/tests/delegates/class-field-initializer.vala new file mode 100644 index 000000000..5a84e4af8 --- /dev/null +++ b/tests/delegates/class-field-initializer.vala @@ -0,0 +1,26 @@ +delegate string FooFunc (); + +FooFunc get_func () { + var s = "foo"; + return () => { return s; }; +} + +class Foo { + public FooFunc func = get_func (); +} + +[Compact] +class Bar { + public FooFunc func = get_func (); +} + +void main () { + { + var foo = new Foo (); + assert (foo.func () == "foo"); + } + { + var bar = new Bar (); + assert (bar.func () == "foo"); + } +}