genie: Accept accessibility and async modifiers on "construct" creation methods

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

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;