From 7210245ef46fe705a2e6c28d653cee1324330a63 Mon Sep 17 00:00:00 2001 From: Rico Tzschichholz Date: Tue, 23 Nov 2021 14:19:02 +0100 Subject: genie: Accept accessibility and async modifiers on "construct" creation methods Fixes https://gitlab.gnome.org/GNOME/vala/issues/1235 --- tests/Makefile.am | 1 + tests/genie/class-abstract.c-expected | 619 ++++++++++++++++++++++++++++++++++ tests/genie/class-abstract.gs | 12 + vala/valagenieparser.vala | 16 +- 4 files changed, 646 insertions(+), 2 deletions(-) create mode 100644 tests/genie/class-abstract.c-expected create mode 100644 tests/genie/class-abstract.gs diff --git a/tests/Makefile.am b/tests/Makefile.am index 2ea1b2e78..b7b1b9f26 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -1251,6 +1251,7 @@ TESTS = \ version/since-parameter.test \ genie/case.gs \ genie/class.gs \ + genie/class-abstract.gs \ genie/class-field.gs \ genie/class-init.gs \ genie/class-property.gs \ diff --git a/tests/genie/class-abstract.c-expected b/tests/genie/class-abstract.c-expected new file mode 100644 index 000000000..82ab96ee1 --- /dev/null +++ b/tests/genie/class-abstract.c-expected @@ -0,0 +1,619 @@ +/* genie_class_abstract.c generated by valac, the Vala compiler + * generated from genie_class_abstract.gs, do not modify */ + +#include +#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 + +#define TYPE_TEST (test_get_type ()) +#define TEST(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TEST, Test)) +#define TEST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TEST, TestClass)) +#define IS_TEST(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TEST)) +#define IS_TEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TEST)) +#define TEST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TEST, TestClass)) + +typedef struct _Test Test; +typedef struct _TestClass TestClass; +typedef struct _TestPrivate TestPrivate; +#define _g_free0(var) (var = (g_free (var), NULL)) +typedef struct _ParamSpecTest ParamSpecTest; + +#define TYPE_TEST2 (test2_get_type ()) +#define TEST2(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_TEST2, Test2)) +#define TEST2_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_TEST2, Test2Class)) +#define IS_TEST2(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_TEST2)) +#define IS_TEST2_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_TEST2)) +#define TEST2_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_TEST2, Test2Class)) + +typedef struct _Test2 Test2; +typedef struct _Test2Class Test2Class; +typedef struct _Test2Private Test2Private; +#define _test2_unref0(var) ((var == NULL) ? NULL : (var = (test2_unref (var), NULL))) +typedef struct _Test2NewData Test2NewData; +typedef struct _ParamSpecTest2 ParamSpecTest2; + +struct _Test { + GTypeInstance parent_instance; + volatile int ref_count; + TestPrivate * priv; + gchar* a; +}; + +struct _TestClass { + GTypeClass parent_class; + void (*finalize) (Test *self); +}; + +struct _ParamSpecTest { + GParamSpec parent_instance; +}; + +struct _Test2 { + GTypeInstance parent_instance; + volatile int ref_count; + Test2Private * priv; + gchar* b; +}; + +struct _Test2Class { + GTypeClass parent_class; + void (*finalize) (Test2 *self); +}; + +struct _Test2NewData { + int _state_; + GObject* _source_object_; + GAsyncResult* _res_; + GTask* _async_result; + GType object_type; + Test2* self; + gchar* _tmp0_; +}; + +struct _ParamSpecTest2 { + GParamSpec parent_instance; +}; + +static gpointer test_parent_class = NULL; +static gpointer test2_parent_class = NULL; + +static void _vala_main (gchar** args, + gint args_length1); +VALA_EXTERN gpointer test_ref (gpointer instance); +VALA_EXTERN void test_unref (gpointer instance); +VALA_EXTERN GParamSpec* param_spec_test (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags); +VALA_EXTERN void value_set_test (GValue* value, + gpointer v_object); +VALA_EXTERN void value_take_test (GValue* value, + gpointer v_object); +VALA_EXTERN gpointer value_get_test (const GValue* value); +VALA_EXTERN GType test_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Test, test_unref) +VALA_EXTERN Test* test_construct (GType object_type); +static void test_finalize (Test * obj); +static GType test_get_type_once (void); +VALA_EXTERN gpointer test2_ref (gpointer instance); +VALA_EXTERN void test2_unref (gpointer instance); +VALA_EXTERN GParamSpec* param_spec_test2 (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags); +VALA_EXTERN void value_set_test2 (GValue* value, + gpointer v_object); +VALA_EXTERN void value_take_test2 (GValue* value, + gpointer v_object); +VALA_EXTERN gpointer value_get_test2 (const GValue* value); +VALA_EXTERN GType test2_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Test2, test2_unref) +static void test2_construct_data_free (gpointer _data); +VALA_EXTERN void test2_construct (GType object_type, + GAsyncReadyCallback _callback_, + gpointer _user_data_); +VALA_EXTERN Test2* test2_construct_finish (GAsyncResult* _res_); +static gboolean test2_construct_co (Test2NewData* _data_); +static void test2_finalize (Test2 * obj); +static GType test2_get_type_once (void); + +static void +_vala_main (gchar** args, + gint args_length1) +{ + g_print ("abstract class\n"); +} + +int +main (int argc, + char ** argv) +{ + _vala_main (argv, argc); + return 0; +} + +Test* +test_construct (GType object_type) +{ + Test* self = NULL; + gchar* _tmp0_; + self = (Test*) g_type_create_instance (object_type); + _tmp0_ = g_strdup ("a"); + _g_free0 (self->a); + self->a = _tmp0_; + return self; +} + +static void +value_test_init (GValue* value) +{ + value->data[0].v_pointer = NULL; +} + +static void +value_test_free_value (GValue* value) +{ + if (value->data[0].v_pointer) { + test_unref (value->data[0].v_pointer); + } +} + +static void +value_test_copy_value (const GValue* src_value, + GValue* dest_value) +{ + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = test_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + +static gpointer +value_test_peek_pointer (const GValue* value) +{ + return value->data[0].v_pointer; +} + +static gchar* +value_test_collect_value (GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + if (collect_values[0].v_pointer) { + Test * 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 = test_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + +static gchar* +value_test_lcopy_value (const GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + Test ** 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 = test_ref (value->data[0].v_pointer); + } + return NULL; +} + +GParamSpec* +param_spec_test (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags) +{ + ParamSpecTest* spec; + g_return_val_if_fail (g_type_is_a (object_type, TYPE_TEST), 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_test (const GValue* value) +{ + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST), NULL); + return value->data[0].v_pointer; +} + +void +value_set_test (GValue* value, + gpointer v_object) +{ + Test * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_TEST)); + 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; + test_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + test_unref (old); + } +} + +void +value_take_test (GValue* value, + gpointer v_object) +{ + Test * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_TEST)); + 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) { + test_unref (old); + } +} + +static void +test_class_init (TestClass * klass, + gpointer klass_data) +{ + test_parent_class = g_type_class_peek_parent (klass); + ((TestClass *) klass)->finalize = test_finalize; +} + +static void +test_instance_init (Test * self, + gpointer klass) +{ + self->ref_count = 1; +} + +static void +test_finalize (Test * obj) +{ + Test * self; + self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_TEST, Test); + g_signal_handlers_destroy (self); + _g_free0 (self->a); +} + +static GType +test_get_type_once (void) +{ + static const GTypeValueTable g_define_type_value_table = { value_test_init, value_test_free_value, value_test_copy_value, value_test_peek_pointer, "p", value_test_collect_value, "p", value_test_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (TestClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) test_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Test), 0, (GInstanceInitFunc) test_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 test_type_id; + test_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Test", &g_define_type_info, &g_define_type_fundamental_info, G_TYPE_FLAG_ABSTRACT); + return test_type_id; +} + +GType +test_get_type (void) +{ + static volatile gsize test_type_id__volatile = 0; + if (g_once_init_enter (&test_type_id__volatile)) { + GType test_type_id; + test_type_id = test_get_type_once (); + g_once_init_leave (&test_type_id__volatile, test_type_id); + } + return test_type_id__volatile; +} + +gpointer +test_ref (gpointer instance) +{ + Test * self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + +void +test_unref (gpointer instance) +{ + Test * self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + TEST_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + +static void +test2_construct_data_free (gpointer _data) +{ + Test2NewData* _data_; + _data_ = _data; + _test2_unref0 (_data_->self); + g_slice_free (Test2NewData, _data_); +} + +void +test2_construct (GType object_type, + GAsyncReadyCallback _callback_, + gpointer _user_data_) +{ + Test2NewData* _data_; + _data_ = g_slice_new0 (Test2NewData); + _data_->_async_result = g_task_new (NULL, NULL, _callback_, _user_data_); + g_task_set_task_data (_data_->_async_result, _data_, test2_construct_data_free); + _data_->object_type = object_type; + test2_construct_co (_data_); +} + +Test2* +test2_construct_finish (GAsyncResult* _res_) +{ + Test2* result; + Test2NewData* _data_; + _data_ = g_task_propagate_pointer (G_TASK (_res_), NULL); + result = _data_->self; + _data_->self = NULL; + return result; +} + +static gboolean +test2_construct_co (Test2NewData* _data_) +{ + Test2* self = NULL; + switch (_data_->_state_) { + case 0: + goto _state_0; + default: + g_assert_not_reached (); + } + _state_0: + _data_->self = (Test2*) g_type_create_instance (_data_->object_type); + _data_->_tmp0_ = g_strdup ("b"); + _g_free0 (_data_->self->b); + _data_->self->b = _data_->_tmp0_; + g_task_return_pointer (_data_->_async_result, _data_, NULL); + if (_data_->_state_ != 0) { + while (!g_task_get_completed (_data_->_async_result)) { + g_main_context_iteration (g_task_get_context (_data_->_async_result), TRUE); + } + } + g_object_unref (_data_->_async_result); + return FALSE; +} + +static void +value_test2_init (GValue* value) +{ + value->data[0].v_pointer = NULL; +} + +static void +value_test2_free_value (GValue* value) +{ + if (value->data[0].v_pointer) { + test2_unref (value->data[0].v_pointer); + } +} + +static void +value_test2_copy_value (const GValue* src_value, + GValue* dest_value) +{ + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = test2_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + +static gpointer +value_test2_peek_pointer (const GValue* value) +{ + return value->data[0].v_pointer; +} + +static gchar* +value_test2_collect_value (GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + if (collect_values[0].v_pointer) { + Test2 * 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 = test2_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + +static gchar* +value_test2_lcopy_value (const GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + Test2 ** 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 = test2_ref (value->data[0].v_pointer); + } + return NULL; +} + +GParamSpec* +param_spec_test2 (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags) +{ + ParamSpecTest2* spec; + g_return_val_if_fail (g_type_is_a (object_type, TYPE_TEST2), 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_test2 (const GValue* value) +{ + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST2), NULL); + return value->data[0].v_pointer; +} + +void +value_set_test2 (GValue* value, + gpointer v_object) +{ + Test2 * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST2)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_TEST2)); + 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; + test2_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + test2_unref (old); + } +} + +void +value_take_test2 (GValue* value, + gpointer v_object) +{ + Test2 * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_TEST2)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_TEST2)); + 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) { + test2_unref (old); + } +} + +static void +test2_class_init (Test2Class * klass, + gpointer klass_data) +{ + test2_parent_class = g_type_class_peek_parent (klass); + ((Test2Class *) klass)->finalize = test2_finalize; +} + +static void +test2_instance_init (Test2 * self, + gpointer klass) +{ + self->ref_count = 1; +} + +static void +test2_finalize (Test2 * obj) +{ + Test2 * self; + self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_TEST2, Test2); + g_signal_handlers_destroy (self); + _g_free0 (self->b); +} + +static GType +test2_get_type_once (void) +{ + static const GTypeValueTable g_define_type_value_table = { value_test2_init, value_test2_free_value, value_test2_copy_value, value_test2_peek_pointer, "p", value_test2_collect_value, "p", value_test2_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (Test2Class), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) test2_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Test2), 0, (GInstanceInitFunc) test2_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 test2_type_id; + test2_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Test2", &g_define_type_info, &g_define_type_fundamental_info, G_TYPE_FLAG_ABSTRACT); + return test2_type_id; +} + +GType +test2_get_type (void) +{ + static volatile gsize test2_type_id__volatile = 0; + if (g_once_init_enter (&test2_type_id__volatile)) { + GType test2_type_id; + test2_type_id = test2_get_type_once (); + g_once_init_leave (&test2_type_id__volatile, test2_type_id); + } + return test2_type_id__volatile; +} + +gpointer +test2_ref (gpointer instance) +{ + Test2 * self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + +void +test2_unref (gpointer instance) +{ + Test2 * self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + TEST2_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + diff --git a/tests/genie/class-abstract.gs b/tests/genie/class-abstract.gs new file mode 100644 index 000000000..b7f894b21 --- /dev/null +++ b/tests/genie/class-abstract.gs @@ -0,0 +1,12 @@ +init + print "abstract class" + +class abstract Test + a:string + construct protected() + a = "a" + +class abstract Test2 + b:string + construct async protected() + b = "b" diff --git a/vala/valagenieparser.vala b/vala/valagenieparser.vala index cc8215a43..60c85e36f 100644 --- a/vala/valagenieparser.vala +++ b/vala/valagenieparser.vala @@ -3696,7 +3696,7 @@ public class Vala.Genie.Parser : CodeVisitor { CreationMethod method; expect (TokenType.CONSTRUCT); - parse_member_declaration_modifiers (); + var flags = parse_member_declaration_modifiers (); if (accept (TokenType.OPEN_PARENS)) { /* create default name using class name */ @@ -3728,9 +3728,21 @@ public class Vala.Genie.Parser : CodeVisitor { method.add_error_type (parse_type (true, false)); } while (accept (TokenType.COMMA)); } - method.access = SymbolAccessibility.PUBLIC; + + if (ModifierFlags.PRIVATE in flags) { + method.access = SymbolAccessibility.PRIVATE; + } else if (ModifierFlags.PROTECTED in flags) { + method.access = SymbolAccessibility.PROTECTED; + } else { + method.access = SymbolAccessibility.PUBLIC; + } + set_attributes (method, attrs); + if (ModifierFlags.ASYNC in flags) { + method.coroutine = true; + } + if (accept_block ()) { method.body = parse_block (); method.external = false; -- cgit v1.2.1