[vala/staging] genie: Accept accessibility and async modifiers on "construct" creation methods

[Rico Tzschichholz <ricotz src gnome org>]

commit 7210245ef46fe705a2e6c28d653cee1324330a63
Author: Rico Tzschichholz <ricotz ubuntu com>
Date:   Tue Nov 23 14:19:02 2021 +0100

    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(-)
---
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 <stdlib.h>
+#include <string.h>
+#include <glib.h>
+#include <glib-object.h>
+#include <gobject/gvaluecollector.h>
+#include <gio/gio.h>
+
+#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;