tests: Add expected generated C sources

19 files changed, 4255 insertions, 0 deletions

diff --git a/tests/semantic/assignment-same-variable.c-expected b/tests/semantic/assignment-same-variable.c-expected
new file mode 100644
index 000000000..e01ab167c
--- /dev/null
+++ b/tests/semantic/assignment-same-variable.c-expected
@@ -0,0 +1,313 @@
+/* semantic_assignment_same_variable.c generated by valac, the Vala compiler
+ * generated from semantic_assignment_same_variable.vala, do not modify */
+
+#include <glib-object.h>
+#include <glib.h>
+#include <gobject/gvaluecollector.h>
+#include <stdlib.h>
+#include <string.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_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;
+#define _g_free0(var) (var = (g_free (var), NULL))
+
+struct _Foo {
+	GTypeInstance parent_instance;
+	volatile int ref_count;
+	FooPrivate * priv;
+	gint i;
+};
+
+struct _FooClass {
+	GTypeClass parent_class;
+	void (*finalize) (Foo *self);
+};
+
+struct _ParamSpecFoo {
+	GParamSpec parent_instance;
+};
+
+static gpointer foo_parent_class = NULL;
+VALA_EXTERN gint i;
+gint i = 0;
+
+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);
+static void _vala_main (void);
+
+Foo*
+foo_construct (GType object_type)
+{
+	Foo* self = NULL;
+	self = (Foo*) g_type_create_instance (object_type);
+	self->i = self->i;
+	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)
+{
+	self->i = 23;
+	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);
+}
+
+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);
+	}
+}
+
+static void
+_vala_main (void)
+{
+	gchar* s = NULL;
+	gchar* _tmp0_;
+	const gchar* _tmp1_;
+	gchar* _tmp2_;
+	_tmp0_ = g_strdup ("foo");
+	s = _tmp0_;
+	_tmp1_ = s;
+	_tmp2_ = g_strdup (_tmp1_);
+	_g_free0 (s);
+	s = _tmp2_;
+	i = 42;
+	i = i;
+	_g_free0 (s);
+}
+
+int
+main (int argc,
+      char ** argv)
+{
+	_vala_main ();
+	return 0;
+}
+
diff --git a/tests/semantic/class-opaque-automatic-property.c-expected b/tests/semantic/class-opaque-automatic-property.c-expected
new file mode 100644
index 000000000..a60070aeb
--- /dev/null
+++ b/tests/semantic/class-opaque-automatic-property.c-expected
@@ -0,0 +1,96 @@
+/* semantic_class_opaque_automatic_property.c generated by valac, the Vala compiler
+ * generated from semantic_class_opaque_automatic_property.vala, do not modify */
+
+#include <glib.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
+
+typedef struct _Foo Foo;
+#define _foo_free0(var) ((var == NULL) ? NULL : (var = (foo_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 _Foo {
+	gint _bar;
+};
+
+VALA_EXTERN void foo_free (Foo * self);
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (Foo, foo_free)
+static void foo_instance_init (Foo * self);
+VALA_EXTERN Foo* foo_new (void);
+VALA_EXTERN gint foo_get_bar (Foo* self);
+VALA_EXTERN void foo_set_bar (Foo* self,
+                  gint value);
+static void _vala_main (void);
+
+Foo*
+foo_new (void)
+{
+	Foo* self;
+	self = g_slice_new0 (Foo);
+	foo_instance_init (self);
+	return self;
+}
+
+gint
+foo_get_bar (Foo* self)
+{
+	gint result;
+	g_return_val_if_fail (self != NULL, 0);
+	result = self->_bar;
+	return result;
+}
+
+void
+foo_set_bar (Foo* self,
+             gint value)
+{
+	g_return_if_fail (self != NULL);
+	self->_bar = value;
+}
+
+static void
+foo_instance_init (Foo * self)
+{
+}
+
+void
+foo_free (Foo * self)
+{
+	g_slice_free (Foo, self);
+}
+
+static void
+_vala_main (void)
+{
+	Foo* foo = NULL;
+	Foo* _tmp0_;
+	gint _tmp1_;
+	gint _tmp2_;
+	_tmp0_ = foo_new ();
+	foo = _tmp0_;
+	foo_set_bar (foo, 42);
+	_tmp1_ = foo_get_bar (foo);
+	_tmp2_ = _tmp1_;
+	_vala_assert (_tmp2_ == 42, "foo.bar == 42");
+	_foo_free0 (foo);
+}
+
+int
+main (int argc,
+      char ** argv)
+{
+	_vala_main ();
+	return 0;
+}
+
diff --git a/tests/semantic/class-opaque.c-expected b/tests/semantic/class-opaque.c-expected
new file mode 100644
index 000000000..48718206e
--- /dev/null
+++ b/tests/semantic/class-opaque.c-expected
@@ -0,0 +1,85 @@
+/* semantic_class_opaque.c generated by valac, the Vala compiler
+ * generated from semantic_class_opaque.vala, do not modify */
+
+#include <glib.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
+
+typedef struct _Foo Foo;
+#define _foo_free0(var) ((var == NULL) ? NULL : (var = (foo_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 _Foo {
+	gint i;
+	gint j;
+};
+
+VALA_EXTERN void foo_free (Foo * self);
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (Foo, foo_free)
+static void foo_instance_init (Foo * self);
+VALA_EXTERN Foo* foo_new (void);
+VALA_EXTERN gint foo_get_i (Foo* self);
+static void _vala_main (void);
+
+Foo*
+foo_new (void)
+{
+	Foo* self;
+	self = g_slice_new0 (Foo);
+	foo_instance_init (self);
+	self->i = 42;
+	return self;
+}
+
+gint
+foo_get_i (Foo* self)
+{
+	gint result = 0;
+	g_return_val_if_fail (self != NULL, 0);
+	result = self->i;
+	return result;
+}
+
+static void
+foo_instance_init (Foo * self)
+{
+}
+
+void
+foo_free (Foo * self)
+{
+	g_slice_free (Foo, self);
+}
+
+static void
+_vala_main (void)
+{
+	Foo* foo = NULL;
+	Foo* _tmp0_;
+	_tmp0_ = foo_new ();
+	foo = _tmp0_;
+	foo->j = 23;
+	_vala_assert (foo->j == 23, "foo.j == 23");
+	_vala_assert (foo_get_i (foo) == 42, "foo.get_i () == 42");
+	_foo_free0 (foo);
+}
+
+int
+main (int argc,
+      char ** argv)
+{
+	_vala_main ();
+	return 0;
+}
+
diff --git a/tests/semantic/floating-reference-base-method.c-expected b/tests/semantic/floating-reference-base-method.c-expected
new file mode 100644
index 000000000..36f0b6a06
--- /dev/null
+++ b/tests/semantic/floating-reference-base-method.c-expected
@@ -0,0 +1,631 @@
+/* semantic_floating_reference_base_method.c generated by valac, the Vala compiler
+ * generated from semantic_floating_reference_base_method.vala, do not modify */
+
+#include <glib-object.h>
+#include <glib.h>
+#include <gobject/gvaluecollector.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_IFOO (ifoo_get_type ())
+#define IFOO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_IFOO, IFoo))
+#define IS_IFOO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_IFOO))
+#define IFOO_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_IFOO, IFooIface))
+
+typedef struct _IFoo IFoo;
+typedef struct _IFooIface IFooIface;
+
+#define TYPE_IBAR (ibar_get_type ())
+#define IBAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_IBAR, IBar))
+#define IS_IBAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_IBAR))
+#define IBAR_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), TYPE_IBAR, IBarIface))
+
+typedef struct _IBar IBar;
+typedef struct _IBarIface IBarIface;
+
+#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;
+
+#define TYPE_MANAM (manam_get_type ())
+#define MANAM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_MANAM, Manam))
+#define MANAM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_MANAM, ManamClass))
+#define IS_MANAM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_MANAM))
+#define IS_MANAM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_MANAM))
+#define MANAM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_MANAM, ManamClass))
+
+typedef struct _Manam Manam;
+typedef struct _ManamClass ManamClass;
+typedef struct _ManamPrivate ManamPrivate;
+#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
+#define _foo_unref0(var) ((var == NULL) ? NULL : (var = (foo_unref (var), NULL)))
+
+struct _IFooIface {
+	GTypeInterface parent_iface;
+	GInitiallyUnowned* (*foo) (IFoo* self);
+};
+
+struct _IBarIface {
+	GTypeInterface parent_iface;
+	GInitiallyUnowned* (*bar) (IBar* self);
+};
+
+struct _Foo {
+	GTypeInstance parent_instance;
+	volatile int ref_count;
+	FooPrivate * priv;
+};
+
+struct _FooClass {
+	GTypeClass parent_class;
+	void (*finalize) (Foo *self);
+	GInitiallyUnowned* (*faz) (Foo* self);
+	GInitiallyUnowned* (*baz) (Foo* self);
+};
+
+struct _ParamSpecFoo {
+	GParamSpec parent_instance;
+};
+
+struct _Manam {
+	Foo parent_instance;
+	ManamPrivate * priv;
+};
+
+struct _ManamClass {
+	FooClass parent_class;
+};
+
+static gpointer foo_parent_class = NULL;
+static IFooIface * foo_ifoo_parent_iface = NULL;
+static IBarIface * foo_ibar_parent_iface = NULL;
+static gpointer manam_parent_class = NULL;
+
+VALA_EXTERN GType ifoo_get_type (void) G_GNUC_CONST ;
+VALA_EXTERN GInitiallyUnowned* ifoo_foo (IFoo* self);
+static GType ifoo_get_type_once (void);
+VALA_EXTERN GType ibar_get_type (void) G_GNUC_CONST ;
+VALA_EXTERN GInitiallyUnowned* ibar_bar (IBar* self);
+static GType ibar_get_type_once (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 GInitiallyUnowned* foo_faz (Foo* self);
+VALA_EXTERN GInitiallyUnowned* foo_baz (Foo* self);
+static GInitiallyUnowned* foo_real_foo (IFoo* base);
+static GInitiallyUnowned* foo_real_bar (IBar* base);
+static GInitiallyUnowned* foo_real_faz (Foo* self);
+static GInitiallyUnowned* foo_real_baz (Foo* self);
+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 GType manam_get_type (void) G_GNUC_CONST ;
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (Manam, foo_unref)
+static GInitiallyUnowned* manam_real_faz (Foo* base);
+static GInitiallyUnowned* manam_real_baz (Foo* base);
+VALA_EXTERN Manam* manam_new (void);
+VALA_EXTERN Manam* manam_construct (GType object_type);
+static GType manam_get_type_once (void);
+static void _vala_main (void);
+
+GInitiallyUnowned*
+ifoo_foo (IFoo* self)
+{
+	IFooIface* _iface_;
+	g_return_val_if_fail (IS_IFOO (self), NULL);
+	_iface_ = IFOO_GET_INTERFACE (self);
+	if (_iface_->foo) {
+		return _iface_->foo (self);
+	}
+	return NULL;
+}
+
+static void
+ifoo_default_init (IFooIface * iface,
+                   gpointer iface_data)
+{
+}
+
+static GType
+ifoo_get_type_once (void)
+{
+	static const GTypeInfo g_define_type_info = { sizeof (IFooIface), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ifoo_default_init, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
+	GType ifoo_type_id;
+	ifoo_type_id = g_type_register_static (G_TYPE_INTERFACE, "IFoo", &g_define_type_info, 0);
+	return ifoo_type_id;
+}
+
+GType
+ifoo_get_type (void)
+{
+	static volatile gsize ifoo_type_id__volatile = 0;
+	if (g_once_init_enter (&ifoo_type_id__volatile)) {
+		GType ifoo_type_id;
+		ifoo_type_id = ifoo_get_type_once ();
+		g_once_init_leave (&ifoo_type_id__volatile, ifoo_type_id);
+	}
+	return ifoo_type_id__volatile;
+}
+
+GInitiallyUnowned*
+ibar_bar (IBar* self)
+{
+	IBarIface* _iface_;
+	g_return_val_if_fail (IS_IBAR (self), NULL);
+	_iface_ = IBAR_GET_INTERFACE (self);
+	if (_iface_->bar) {
+		return _iface_->bar (self);
+	}
+	return NULL;
+}
+
+static void
+ibar_default_init (IBarIface * iface,
+                   gpointer iface_data)
+{
+}
+
+static GType
+ibar_get_type_once (void)
+{
+	static const GTypeInfo g_define_type_info = { sizeof (IBarIface), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) ibar_default_init, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
+	GType ibar_type_id;
+	ibar_type_id = g_type_register_static (G_TYPE_INTERFACE, "IBar", &g_define_type_info, 0);
+	return ibar_type_id;
+}
+
+GType
+ibar_get_type (void)
+{
+	static volatile gsize ibar_type_id__volatile = 0;
+	if (g_once_init_enter (&ibar_type_id__volatile)) {
+		GType ibar_type_id;
+		ibar_type_id = ibar_get_type_once ();
+		g_once_init_leave (&ibar_type_id__volatile, ibar_type_id);
+	}
+	return ibar_type_id__volatile;
+}
+
+static GInitiallyUnowned*
+foo_real_foo (IFoo* base)
+{
+	Foo * self;
+	GInitiallyUnowned* result = NULL;
+	self = G_TYPE_CHECK_INSTANCE_CAST (base, TYPE_FOO, Foo);
+	result = NULL;
+	return result;
+}
+
+static GInitiallyUnowned*
+foo_real_bar (IBar* base)
+{
+	Foo * self;
+	GInitiallyUnowned* result = NULL;
+	self = G_TYPE_CHECK_INSTANCE_CAST (base, TYPE_FOO, Foo);
+	result = NULL;
+	return result;
+}
+
+static GInitiallyUnowned*
+foo_real_faz (Foo* self)
+{
+	GInitiallyUnowned* result = NULL;
+	result = NULL;
+	return result;
+}
+
+GInitiallyUnowned*
+foo_faz (Foo* self)
+{
+	FooClass* _klass_;
+	g_return_val_if_fail (IS_FOO (self), NULL);
+	_klass_ = FOO_GET_CLASS (self);
+	if (_klass_->faz) {
+		return _klass_->faz (self);
+	}
+	return NULL;
+}
+
+static GInitiallyUnowned*
+foo_real_baz (Foo* self)
+{
+	GInitiallyUnowned* result = NULL;
+	result = NULL;
+	return result;
+}
+
+GInitiallyUnowned*
+foo_baz (Foo* self)
+{
+	FooClass* _klass_;
+	g_return_val_if_fail (IS_FOO (self), NULL);
+	_klass_ = FOO_GET_CLASS (self);
+	if (_klass_->baz) {
+		return _klass_->baz (self);
+	}
+	return NULL;
+}
+
+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;
+	((FooClass *) klass)->faz = (GInitiallyUnowned* (*) (Foo*)) foo_real_faz;
+	((FooClass *) klass)->baz = (GInitiallyUnowned* (*) (Foo*)) foo_real_baz;
+}
+
+static void
+foo_ifoo_interface_init (IFooIface * iface,
+                         gpointer iface_data)
+{
+	foo_ifoo_parent_iface = g_type_interface_peek_parent (iface);
+	iface->foo = (GInitiallyUnowned* (*) (IFoo*)) foo_real_foo;
+}
+
+static void
+foo_ibar_interface_init (IBarIface * iface,
+                         gpointer iface_data)
+{
+	foo_ibar_parent_iface = g_type_interface_peek_parent (iface);
+	iface->bar = (GInitiallyUnowned* (*) (IBar*)) foo_real_bar;
+}
+
+static void
+foo_instance_init (Foo * self,
+                   gpointer klass)
+{
+	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);
+}
+
+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) };
+	static const GInterfaceInfo ifoo_info = { (GInterfaceInitFunc) foo_ifoo_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
+	static const GInterfaceInfo ibar_info = { (GInterfaceInitFunc) foo_ibar_interface_init, (GInterfaceFinalizeFunc) NULL, NULL};
+	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);
+	g_type_add_interface_static (foo_type_id, TYPE_IFOO, &ifoo_info);
+	g_type_add_interface_static (foo_type_id, TYPE_IBAR, &ibar_info);
+	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);
+	}
+}
+
+static GInitiallyUnowned*
+manam_real_faz (Foo* base)
+{
+	Manam * self;
+	GInitiallyUnowned* result = NULL;
+	self = G_TYPE_CHECK_INSTANCE_CAST (base, TYPE_MANAM, Manam);
+	result = NULL;
+	return result;
+}
+
+static GInitiallyUnowned*
+manam_real_baz (Foo* base)
+{
+	Manam * self;
+	GInitiallyUnowned* result = NULL;
+	self = G_TYPE_CHECK_INSTANCE_CAST (base, TYPE_MANAM, Manam);
+	result = NULL;
+	return result;
+}
+
+Manam*
+manam_construct (GType object_type)
+{
+	Manam* self = NULL;
+	self = (Manam*) foo_construct (object_type);
+	return self;
+}
+
+Manam*
+manam_new (void)
+{
+	return manam_construct (TYPE_MANAM);
+}
+
+static void
+manam_class_init (ManamClass * klass,
+                  gpointer klass_data)
+{
+	manam_parent_class = g_type_class_peek_parent (klass);
+	((FooClass *) klass)->faz = (GInitiallyUnowned* (*) (Foo*)) manam_real_faz;
+	((FooClass *) klass)->baz = (GInitiallyUnowned* (*) (Foo*)) manam_real_baz;
+}
+
+static void
+manam_instance_init (Manam * self,
+                     gpointer klass)
+{
+}
+
+static GType
+manam_get_type_once (void)
+{
+	static const GTypeInfo g_define_type_info = { sizeof (ManamClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) manam_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Manam), 0, (GInstanceInitFunc) manam_instance_init, NULL };
+	GType manam_type_id;
+	manam_type_id = g_type_register_static (TYPE_FOO, "Manam", &g_define_type_info, 0);
+	return manam_type_id;
+}
+
+GType
+manam_get_type (void)
+{
+	static volatile gsize manam_type_id__volatile = 0;
+	if (g_once_init_enter (&manam_type_id__volatile)) {
+		GType manam_type_id;
+		manam_type_id = manam_get_type_once ();
+		g_once_init_leave (&manam_type_id__volatile, manam_type_id);
+	}
+	return manam_type_id__volatile;
+}
+
+static void
+_vala_main (void)
+{
+	Manam* manam = NULL;
+	Manam* _tmp0_;
+	GInitiallyUnowned* _tmp1_;
+	GInitiallyUnowned* _tmp2_;
+	GInitiallyUnowned* _tmp3_;
+	GInitiallyUnowned* _tmp4_;
+	GInitiallyUnowned* _tmp5_;
+	GInitiallyUnowned* _tmp6_;
+	GInitiallyUnowned* _tmp7_;
+	GInitiallyUnowned* _tmp8_;
+	_tmp0_ = manam_new ();
+	manam = _tmp0_;
+	_tmp1_ = ifoo_foo (G_TYPE_CHECK_INSTANCE_CAST (manam, TYPE_IFOO, IFoo));
+	if (_tmp1_ != NULL) {
+		g_object_ref_sink (_tmp1_);
+	}
+	_tmp2_ = _tmp1_;
+	_g_object_unref0 (_tmp2_);
+	_tmp3_ = ibar_bar (G_TYPE_CHECK_INSTANCE_CAST (manam, TYPE_IBAR, IBar));
+	if (_tmp3_ != NULL) {
+		g_object_ref_sink (_tmp3_);
+	}
+	_tmp4_ = _tmp3_;
+	_g_object_unref0 (_tmp4_);
+	_tmp5_ = foo_faz (G_TYPE_CHECK_INSTANCE_CAST (manam, TYPE_FOO, Foo));
+	if (_tmp5_ != NULL) {
+		g_object_ref_sink (_tmp5_);
+	}
+	_tmp6_ = _tmp5_;
+	_g_object_unref0 (_tmp6_);
+	_tmp7_ = foo_baz (G_TYPE_CHECK_INSTANCE_CAST (manam, TYPE_FOO, Foo));
+	if (_tmp7_ != NULL) {
+		g_object_ref_sink (_tmp7_);
+	}
+	_tmp8_ = _tmp7_;
+	_g_object_unref0 (_tmp8_);
+	_foo_unref0 (manam);
+}
+
+int
+main (int argc,
+      char ** argv)
+{
+	_vala_main ();
+	return 0;
+}
+
diff --git a/tests/semantic/floating-reference-error.c-expected b/tests/semantic/floating-reference-error.c-expected
new file mode 100644
index 000000000..862e51930
--- /dev/null
+++ b/tests/semantic/floating-reference-error.c-expected
@@ -0,0 +1,107 @@
+/* semantic_floating_reference_error.c generated by valac, the Vala compiler
+ * generated from semantic_floating_reference_error.vala, do not modify */
+
+#include <glib.h>
+#include <stdarg.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 _g_variant_unref0(var) ((var == NULL) ? NULL : (var = (g_variant_unref (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);
+
+VALA_EXTERN GVariant* get_floating_variant_with_error (GError** error);
+VALA_EXTERN void variant_args (gint first,
+                   ...);
+static void _vala_main (void);
+
+GVariant*
+get_floating_variant_with_error (GError** error)
+{
+	GVariant* _tmp0_;
+	GVariant* result = NULL;
+	_tmp0_ = g_variant_new_string ("bar");
+	result = _tmp0_;
+	return result;
+}
+
+void
+variant_args (gint first,
+              ...)
+{
+	va_list va = {0};
+	GVariant* _tmp0_;
+	va_start (va, first);
+	_tmp0_ = va_arg (va, GVariant*);
+	_vala_assert (!g_variant_is_floating (_tmp0_), "!va.arg<Variant> ().is_floating ()");
+	va_end (va);
+}
+
+static void
+_vala_main (void)
+{
+	GError* _inner_error0_ = NULL;
+	{
+		GVariant* _tmp0_ = NULL;
+		GVariant* _tmp1_;
+		_tmp1_ = get_floating_variant_with_error (&_inner_error0_);
+		if (_tmp1_ != NULL) {
+			g_variant_ref_sink (_tmp1_);
+		}
+		_tmp0_ = _tmp1_;
+		if (G_UNLIKELY (_inner_error0_ != NULL)) {
+			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
+			g_clear_error (&_inner_error0_);
+			return;
+		}
+		variant_args (23, _tmp0_, NULL);
+		_g_variant_unref0 (_tmp0_);
+	}
+	{
+		{
+			GVariant* _tmp2_ = NULL;
+			GVariant* _tmp3_;
+			_tmp3_ = get_floating_variant_with_error (&_inner_error0_);
+			if (_tmp3_ != NULL) {
+				g_variant_ref_sink (_tmp3_);
+			}
+			_tmp2_ = _tmp3_;
+			if (G_UNLIKELY (_inner_error0_ != NULL)) {
+				goto __catch0_g_error;
+			}
+			variant_args (42, _tmp2_, NULL);
+			_g_variant_unref0 (_tmp2_);
+		}
+		goto __finally0;
+		__catch0_g_error:
+		{
+			g_clear_error (&_inner_error0_);
+			g_assert_not_reached ();
+		}
+		__finally0:
+		if (G_UNLIKELY (_inner_error0_ != NULL)) {
+			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
+			g_clear_error (&_inner_error0_);
+			return;
+		}
+	}
+}
+
+int
+main (int argc,
+      char ** argv)
+{
+	_vala_main ();
+	return 0;
+}
+
diff --git a/tests/semantic/floating-reference.c-expected b/tests/semantic/floating-reference.c-expected
new file mode 100644
index 000000000..f15e34da0
--- /dev/null
+++ b/tests/semantic/floating-reference.c-expected
@@ -0,0 +1,330 @@
+/* semantic_floating_reference.c generated by valac, the Vala compiler
+ * generated from semantic_floating_reference.vala, do not modify */
+
+#include <glib.h>
+#include <stdlib.h>
+#include <string.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 _g_variant_unref0(var) ((var == NULL) ? NULL : (var = (g_variant_unref (var), NULL)))
+#define _g_free0(var) (var = (g_free (var), NULL))
+#define _g_variant_type_free0(var) ((var == NULL) ? NULL : (var = (g_variant_type_free (var), NULL)))
+#define _g_variant_builder_unref0(var) ((var == NULL) ? NULL : (var = (g_variant_builder_unref (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);
+
+VALA_EXTERN GVariant* get_floating_variant (void);
+VALA_EXTERN GVariant* get_floating_variant_with_error (GError** error);
+VALA_EXTERN void test_variant (void);
+static gchar* _variant_get1 (GVariant* value);
+VALA_EXTERN void test_variant_builder (void);
+static void _vala_main (void);
+
+GVariant*
+get_floating_variant (void)
+{
+	GVariant* _tmp0_;
+	GVariant* result = NULL;
+	_tmp0_ = g_variant_new_string ("foo");
+	result = _tmp0_;
+	return result;
+}
+
+GVariant*
+get_floating_variant_with_error (GError** error)
+{
+	GVariant* _tmp0_;
+	GVariant* result = NULL;
+	_tmp0_ = g_variant_new_string ("bar");
+	result = _tmp0_;
+	return result;
+}
+
+static gpointer
+_g_variant_ref0 (gpointer self)
+{
+	return self ? g_variant_ref (self) : NULL;
+}
+
+static gchar*
+_variant_get1 (GVariant* value)
+{
+	return g_variant_dup_string (value, NULL);
+}
+
+void
+test_variant (void)
+{
+	GError* _inner_error0_ = NULL;
+	{
+		gchar* value = NULL;
+		gchar* _tmp0_;
+		GVariant* _tmp1_ = NULL;
+		const gchar* _tmp2_;
+		GVariant* _tmp3_;
+		GVariant* variant = NULL;
+		GVariant* _tmp6_;
+		GVariant* _tmp7_;
+		const GVariantType* _tmp8_;
+		GVariant* _tmp9_;
+		_tmp0_ = g_strdup ("bar");
+		value = _tmp0_;
+		_tmp2_ = value;
+		_tmp3_ = g_variant_new_string (_tmp2_);
+		_tmp1_ = _tmp3_;
+		if (_tmp1_ == NULL) {
+			const gchar* _tmp4_;
+			GVariant* _tmp5_;
+			_tmp4_ = value;
+			_tmp5_ = g_variant_new_string (_tmp4_);
+			_g_variant_unref0 (_tmp1_);
+			_tmp1_ = _tmp5_;
+		}
+		_tmp6_ = _tmp1_;
+		_tmp1_ = NULL;
+		if (_tmp6_ != NULL) {
+			g_variant_ref_sink (_tmp6_);
+		}
+		variant = _tmp6_;
+		_tmp7_ = variant;
+		_tmp8_ = G_VARIANT_TYPE_STRING;
+		_vala_assert (g_variant_is_of_type (_tmp7_, _tmp8_), "variant.is_of_type (VariantType.STRING)");
+		_tmp9_ = variant;
+		_vala_assert (!g_variant_is_floating (_tmp9_), "!variant.is_floating ()");
+		_g_variant_unref0 (variant);
+		_g_variant_unref0 (_tmp1_);
+		_g_free0 (value);
+	}
+	{
+		gchar* value = NULL;
+		gchar* _tmp10_;
+		GVariant* _tmp11_ = NULL;
+		const gchar* _tmp12_;
+		GVariant* variant = NULL;
+		GVariant* _tmp15_;
+		GVariant* _tmp16_;
+		const GVariantType* _tmp17_;
+		GVariant* _tmp18_;
+		_tmp10_ = g_strdup ("foo");
+		value = _tmp10_;
+		_tmp12_ = value;
+		if (_tmp12_ == NULL) {
+			_g_variant_unref0 (_tmp11_);
+			_tmp11_ = NULL;
+		} else {
+			const gchar* _tmp13_;
+			GVariant* _tmp14_;
+			_tmp13_ = value;
+			_tmp14_ = g_variant_new_string (_tmp13_);
+			g_variant_ref_sink (_tmp14_);
+			_g_variant_unref0 (_tmp11_);
+			_tmp11_ = _tmp14_;
+		}
+		_tmp15_ = _g_variant_ref0 (_tmp11_);
+		variant = _tmp15_;
+		_tmp16_ = variant;
+		_tmp17_ = G_VARIANT_TYPE_STRING;
+		_vala_assert (g_variant_is_of_type (_tmp16_, _tmp17_), "variant.is_of_type (VariantType.STRING)");
+		_tmp18_ = variant;
+		_vala_assert (!g_variant_is_floating (_tmp18_), "!variant.is_floating ()");
+		_g_variant_unref0 (variant);
+		_g_variant_unref0 (_tmp11_);
+		_g_free0 (value);
+	}
+	{
+		gchar* value = NULL;
+		gchar* _tmp19_;
+		GVariant* variant = NULL;
+		const gchar* _tmp20_;
+		GVariant* _tmp23_;
+		const GVariantType* _tmp24_;
+		GVariant* _tmp25_;
+		_tmp19_ = g_strdup ("foo");
+		value = _tmp19_;
+		_tmp20_ = value;
+		if (_tmp20_ == NULL) {
+			_g_variant_unref0 (variant);
+			variant = NULL;
+		} else {
+			const gchar* _tmp21_;
+			GVariant* _tmp22_;
+			_tmp21_ = value;
+			_tmp22_ = g_variant_new_string (_tmp21_);
+			g_variant_ref_sink (_tmp22_);
+			_g_variant_unref0 (variant);
+			variant = _tmp22_;
+		}
+		_tmp23_ = variant;
+		_tmp24_ = G_VARIANT_TYPE_STRING;
+		_vala_assert (g_variant_is_of_type (_tmp23_, _tmp24_), "variant.is_of_type (VariantType.STRING)");
+		_tmp25_ = variant;
+		_vala_assert (!g_variant_is_floating (_tmp25_), "!variant.is_floating ()");
+		_g_variant_unref0 (variant);
+		_g_free0 (value);
+	}
+	{
+		gboolean value = FALSE;
+		GVariant* variant = NULL;
+		GVariant* _tmp26_;
+		const GVariantType* _tmp27_;
+		value = TRUE;
+		_tmp26_ = g_variant_new_boolean (value);
+		g_variant_ref_sink (_tmp26_);
+		variant = _tmp26_;
+		_tmp27_ = G_VARIANT_TYPE_BOOLEAN;
+		_vala_assert (g_variant_is_of_type (variant, _tmp27_), "variant.is_of_type (VariantType.BOOLEAN)");
+		_vala_assert (!g_variant_is_floating (variant), "!variant.is_floating ()");
+		_g_variant_unref0 (variant);
+	}
+	{
+		gchar* value = NULL;
+		gchar* _tmp28_;
+		GVariant* variant = NULL;
+		GVariant* _tmp29_;
+		const GVariantType* _tmp30_;
+		gchar* s = NULL;
+		gchar* _tmp31_;
+		_tmp28_ = g_strdup ("manam");
+		value = _tmp28_;
+		_tmp29_ = g_variant_new_string (value);
+		g_variant_ref_sink (_tmp29_);
+		variant = _tmp29_;
+		_tmp30_ = G_VARIANT_TYPE_STRING;
+		_vala_assert (g_variant_is_of_type (variant, _tmp30_), "variant.is_of_type (VariantType.STRING)");
+		_vala_assert (!g_variant_is_floating (variant), "!variant.is_floating ()");
+		_tmp31_ = _variant_get1 (variant);
+		s = _tmp31_;
+		_vala_assert (g_strcmp0 (s, "manam") == 0, "s == \"manam\"");
+		_g_free0 (s);
+		_g_variant_unref0 (variant);
+		_g_free0 (value);
+	}
+	{
+		GVariant* variant = NULL;
+		GVariant* _tmp32_;
+		_tmp32_ = get_floating_variant ();
+		g_variant_ref_sink (_tmp32_);
+		variant = _tmp32_;
+		_vala_assert (!g_variant_is_floating (variant), "!variant.is_floating ()");
+		_g_variant_unref0 (variant);
+	}
+	{
+		GVariant* variant = NULL;
+		GVariant* _tmp33_;
+		_tmp33_ = get_floating_variant_with_error (&_inner_error0_);
+		if (_tmp33_ != NULL) {
+			g_variant_ref_sink (_tmp33_);
+		}
+		variant = _tmp33_;
+		if (G_UNLIKELY (_inner_error0_ != NULL)) {
+			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
+			g_clear_error (&_inner_error0_);
+			return;
+		}
+		_vala_assert (!g_variant_is_floating (variant), "!variant.is_floating ()");
+		_g_variant_unref0 (variant);
+	}
+	{
+		{
+			GVariant* variant = NULL;
+			GVariant* _tmp34_;
+			GVariant* _tmp35_;
+			_tmp34_ = get_floating_variant_with_error (&_inner_error0_);
+			if (_tmp34_ != NULL) {
+				g_variant_ref_sink (_tmp34_);
+			}
+			variant = _tmp34_;
+			if (G_UNLIKELY (_inner_error0_ != NULL)) {
+				goto __catch0_g_error;
+			}
+			_tmp35_ = variant;
+			_vala_assert (!g_variant_is_floating (_tmp35_), "!variant.is_floating ()");
+			_g_variant_unref0 (variant);
+		}
+		goto __finally0;
+		__catch0_g_error:
+		{
+			g_clear_error (&_inner_error0_);
+			g_assert_not_reached ();
+		}
+		__finally0:
+		if (G_UNLIKELY (_inner_error0_ != NULL)) {
+			g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error0_->message, g_quark_to_string (_inner_error0_->domain), _inner_error0_->code);
+			g_clear_error (&_inner_error0_);
+			return;
+		}
+	}
+}
+
+void
+test_variant_builder (void)
+{
+	gchar* name = NULL;
+	gchar* _tmp0_;
+	gchar* key = NULL;
+	gchar* _tmp1_;
+	GVariant* value = NULL;
+	GVariantBuilder* builder = NULL;
+	GVariantType* _tmp2_;
+	GVariantType* _tmp3_;
+	GVariantBuilder* _tmp4_;
+	GVariantBuilder* _tmp5_;
+	GVariant* variant = NULL;
+	GVariant* _tmp6_;
+	GVariant* _tmp7_;
+	GVariant* _tmp8_;
+	GVariant* _tmp9_;
+	_tmp0_ = g_strdup ("foo");
+	name = _tmp0_;
+	_tmp1_ = g_strdup ("bar");
+	key = _tmp1_;
+	value = NULL;
+	_tmp2_ = g_variant_type_new ("a{smv}");
+	_tmp3_ = _tmp2_;
+	_tmp4_ = g_variant_builder_new (_tmp3_);
+	_tmp5_ = _tmp4_;
+	_g_variant_type_free0 (_tmp3_);
+	builder = _tmp5_;
+	g_variant_builder_add (builder, "{smv}", key, value, NULL);
+	_tmp6_ = g_variant_builder_end (builder);
+	g_variant_ref_sink (_tmp6_);
+	_tmp7_ = _tmp6_;
+	_tmp8_ = g_variant_new ("(s@a{smv})", name, _tmp7_, NULL);
+	g_variant_ref_sink (_tmp8_);
+	_tmp9_ = _tmp8_;
+	_g_variant_unref0 (_tmp7_);
+	variant = _tmp9_;
+	_vala_assert (!g_variant_is_floating (variant), "!variant.is_floating ()");
+	_g_variant_unref0 (variant);
+	_g_variant_builder_unref0 (builder);
+	_g_variant_unref0 (value);
+	_g_free0 (key);
+	_g_free0 (name);
+}
+
+static void
+_vala_main (void)
+{
+	test_variant ();
+	test_variant_builder ();
+}
+
+int
+main (int argc,
+      char ** argv)
+{
+	_vala_main ();
+	return 0;
+}
+
diff --git a/tests/semantic/localvariable-var-pointer-initializer.c-expected b/tests/semantic/localvariable-var-pointer-initializer.c-expected
new file mode 100644
index 000000000..b4bf0569a
--- /dev/null
+++ b/tests/semantic/localvariable-var-pointer-initializer.c-expected
@@ -0,0 +1,135 @@
+/* semantic_localvariable_var_pointer_initializer.c generated by valac, the Vala compiler
+ * generated from semantic_localvariable_var_pointer_initializer.vala, do not modify */
+
+#include <glib-object.h>
+#include <stdlib.h>
+#include <string.h>
+#include <glib.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_FOO (foo_get_type ())
+typedef struct _Foo Foo;
+#define _g_free0(var) (var = (g_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 _Foo {
+	gchar* s;
+};
+
+VALA_EXTERN GType foo_get_type (void) G_GNUC_CONST ;
+VALA_EXTERN Foo* foo_dup (const Foo* self);
+VALA_EXTERN void foo_free (Foo* self);
+VALA_EXTERN void foo_copy (const Foo* self,
+               Foo* dest);
+VALA_EXTERN void foo_destroy (Foo* self);
+static void _vala_main (void);
+
+void
+foo_copy (const Foo* self,
+          Foo* dest)
+{
+	const gchar* _tmp0_;
+	gchar* _tmp1_;
+	_tmp0_ = (*self).s;
+	_tmp1_ = g_strdup (_tmp0_);
+	_g_free0 ((*dest).s);
+	(*dest).s = _tmp1_;
+}
+
+void
+foo_destroy (Foo* self)
+{
+	_g_free0 ((*self).s);
+}
+
+Foo*
+foo_dup (const Foo* self)
+{
+	Foo* dup;
+	dup = g_new0 (Foo, 1);
+	foo_copy (self, dup);
+	return dup;
+}
+
+void
+foo_free (Foo* self)
+{
+	foo_destroy (self);
+	g_free (self);
+}
+
+static GType
+foo_get_type_once (void)
+{
+	GType foo_type_id;
+	foo_type_id = g_boxed_type_register_static ("Foo", (GBoxedCopyFunc) foo_dup, (GBoxedFreeFunc) foo_free);
+	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;
+}
+
+static void
+_vala_main (void)
+{
+	{
+		Foo foo = {0};
+		gchar* _tmp0_;
+		Foo _tmp1_ = {0};
+		Foo* foo_p = NULL;
+		const gchar* _tmp2_;
+		_tmp0_ = g_strdup ("foo");
+		_g_free0 (_tmp1_.s);
+		_tmp1_.s = _tmp0_;
+		foo = _tmp1_;
+		foo_p = &foo;
+		_tmp2_ = (*foo_p).s;
+		_vala_assert (g_strcmp0 (_tmp2_, "foo") == 0, "foo_p.s == \"foo\"");
+		foo_destroy (&foo);
+	}
+	{
+		Foo bar = {0};
+		gchar* _tmp3_;
+		Foo _tmp4_ = {0};
+		Foo* bar_p = NULL;
+		const gchar* _tmp5_;
+		_tmp3_ = g_strdup ("bar");
+		_g_free0 (_tmp4_.s);
+		_tmp4_.s = _tmp3_;
+		bar = _tmp4_;
+		bar_p = &bar;
+		_tmp5_ = (*bar_p).s;
+		_vala_assert (g_strcmp0 (_tmp5_, "bar") == 0, "bar_p.s == \"bar\"");
+		foo_destroy (&bar);
+	}
+}
+
+int
+main (int argc,
+      char ** argv)
+{
+	_vala_main ();
+	return 0;
+}
+
diff --git a/tests/semantic/member-access-static-transformed-qualified.c-expected b/tests/semantic/member-access-static-transformed-qualified.c-expected
new file mode 100644
index 000000000..825bb0c07
--- /dev/null
+++ b/tests/semantic/member-access-static-transformed-qualified.c-expected
@@ -0,0 +1,563 @@
+/* semantic_member_access_static_transformed_qualified.c generated by valac, the Vala compiler
+ * generated from semantic_member_access_static_transformed_qualified.vala, do not modify */
+
+#include <glib-object.h>
+#include <gobject/gvaluecollector.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 MANAM_TYPE_MANAM (manam_manam_get_type ())
+#define MANAM_MANAM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MANAM_TYPE_MANAM, ManamManam))
+#define MANAM_MANAM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MANAM_TYPE_MANAM, ManamManamClass))
+#define MANAM_IS_MANAM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MANAM_TYPE_MANAM))
+#define MANAM_IS_MANAM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MANAM_TYPE_MANAM))
+#define MANAM_MANAM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MANAM_TYPE_MANAM, ManamManamClass))
+
+typedef struct _ManamManam ManamManam;
+typedef struct _ManamManamClass ManamManamClass;
+typedef struct _ManamManamPrivate ManamManamPrivate;
+typedef struct _ManamParamSpecManam ManamParamSpecManam;
+
+#define MANAM_TYPE_FOO (manam_foo_get_type ())
+#define MANAM_FOO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), MANAM_TYPE_FOO, ManamFoo))
+#define MANAM_FOO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), MANAM_TYPE_FOO, ManamFooClass))
+#define MANAM_IS_FOO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MANAM_TYPE_FOO))
+#define MANAM_IS_FOO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MANAM_TYPE_FOO))
+#define MANAM_FOO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), MANAM_TYPE_FOO, ManamFooClass))
+
+typedef struct _ManamFoo ManamFoo;
+typedef struct _ManamFooClass ManamFooClass;
+typedef struct _ManamFooPrivate ManamFooPrivate;
+typedef struct _ManamParamSpecFoo ManamParamSpecFoo;
+#define _manam_foo_unref0(var) ((var == NULL) ? NULL : (var = (manam_foo_unref (var), NULL)))
+
+struct _ManamManam {
+	GTypeInstance parent_instance;
+	volatile int ref_count;
+	ManamManamPrivate * priv;
+};
+
+struct _ManamManamClass {
+	GTypeClass parent_class;
+	void (*finalize) (ManamManam *self);
+};
+
+struct _ManamParamSpecManam {
+	GParamSpec parent_instance;
+};
+
+struct _ManamFoo {
+	GTypeInstance parent_instance;
+	volatile int ref_count;
+	ManamFooPrivate * priv;
+};
+
+struct _ManamFooClass {
+	GTypeClass parent_class;
+	void (*finalize) (ManamFoo *self);
+};
+
+struct _ManamParamSpecFoo {
+	GParamSpec parent_instance;
+};
+
+static gpointer manam_manam_parent_class = NULL;
+static gpointer manam_foo_parent_class = NULL;
+
+VALA_EXTERN gpointer manam_manam_ref (gpointer instance);
+VALA_EXTERN void manam_manam_unref (gpointer instance);
+VALA_EXTERN GParamSpec* manam_param_spec_manam (const gchar* name,
+                                    const gchar* nick,
+                                    const gchar* blurb,
+                                    GType object_type,
+                                    GParamFlags flags);
+VALA_EXTERN void manam_value_set_manam (GValue* value,
+                            gpointer v_object);
+VALA_EXTERN void manam_value_take_manam (GValue* value,
+                             gpointer v_object);
+VALA_EXTERN gpointer manam_value_get_manam (const GValue* value);
+VALA_EXTERN GType manam_manam_get_type (void) G_GNUC_CONST ;
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (ManamManam, manam_manam_unref)
+VALA_EXTERN ManamManam* manam_manam_new (void);
+VALA_EXTERN ManamManam* manam_manam_construct (GType object_type);
+static void manam_manam_finalize (ManamManam * obj);
+static GType manam_manam_get_type_once (void);
+VALA_EXTERN gpointer manam_foo_ref (gpointer instance);
+VALA_EXTERN void manam_foo_unref (gpointer instance);
+VALA_EXTERN GParamSpec* manam_param_spec_foo (const gchar* name,
+                                  const gchar* nick,
+                                  const gchar* blurb,
+                                  GType object_type,
+                                  GParamFlags flags);
+VALA_EXTERN void manam_value_set_foo (GValue* value,
+                          gpointer v_object);
+VALA_EXTERN void manam_value_take_foo (GValue* value,
+                           gpointer v_object);
+VALA_EXTERN gpointer manam_value_get_foo (const GValue* value);
+VALA_EXTERN GType manam_foo_get_type (void) G_GNUC_CONST ;
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (ManamFoo, manam_foo_unref)
+VALA_EXTERN void manam_foo_bar (void);
+VALA_EXTERN ManamFoo* manam_foo_new (void);
+VALA_EXTERN ManamFoo* manam_foo_construct (GType object_type);
+static void manam_foo_finalize (ManamFoo * obj);
+static GType manam_foo_get_type_once (void);
+static void manam_main (void);
+
+ManamManam*
+manam_manam_construct (GType object_type)
+{
+	ManamManam* self = NULL;
+	self = (ManamManam*) g_type_create_instance (object_type);
+	return self;
+}
+
+ManamManam*
+manam_manam_new (void)
+{
+	return manam_manam_construct (MANAM_TYPE_MANAM);
+}
+
+static void
+manam_value_manam_init (GValue* value)
+{
+	value->data[0].v_pointer = NULL;
+}
+
+static void
+manam_value_manam_free_value (GValue* value)
+{
+	if (value->data[0].v_pointer) {
+		manam_manam_unref (value->data[0].v_pointer);
+	}
+}
+
+static void
+manam_value_manam_copy_value (const GValue* src_value,
+                              GValue* dest_value)
+{
+	if (src_value->data[0].v_pointer) {
+		dest_value->data[0].v_pointer = manam_manam_ref (src_value->data[0].v_pointer);
+	} else {
+		dest_value->data[0].v_pointer = NULL;
+	}
+}
+
+static gpointer
+manam_value_manam_peek_pointer (const GValue* value)
+{
+	return value->data[0].v_pointer;
+}
+
+static gchar*
+manam_value_manam_collect_value (GValue* value,
+                                 guint n_collect_values,
+                                 GTypeCValue* collect_values,
+                                 guint collect_flags)
+{
+	if (collect_values[0].v_pointer) {
+		ManamManam * 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 = manam_manam_ref (object);
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	return NULL;
+}
+
+static gchar*
+manam_value_manam_lcopy_value (const GValue* value,
+                               guint n_collect_values,
+                               GTypeCValue* collect_values,
+                               guint collect_flags)
+{
+	ManamManam ** 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 = manam_manam_ref (value->data[0].v_pointer);
+	}
+	return NULL;
+}
+
+GParamSpec*
+manam_param_spec_manam (const gchar* name,
+                        const gchar* nick,
+                        const gchar* blurb,
+                        GType object_type,
+                        GParamFlags flags)
+{
+	ManamParamSpecManam* spec;
+	g_return_val_if_fail (g_type_is_a (object_type, MANAM_TYPE_MANAM), 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
+manam_value_get_manam (const GValue* value)
+{
+	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MANAM_TYPE_MANAM), NULL);
+	return value->data[0].v_pointer;
+}
+
+void
+manam_value_set_manam (GValue* value,
+                       gpointer v_object)
+{
+	ManamManam * old;
+	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MANAM_TYPE_MANAM));
+	old = value->data[0].v_pointer;
+	if (v_object) {
+		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MANAM_TYPE_MANAM));
+		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;
+		manam_manam_ref (value->data[0].v_pointer);
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	if (old) {
+		manam_manam_unref (old);
+	}
+}
+
+void
+manam_value_take_manam (GValue* value,
+                        gpointer v_object)
+{
+	ManamManam * old;
+	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MANAM_TYPE_MANAM));
+	old = value->data[0].v_pointer;
+	if (v_object) {
+		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MANAM_TYPE_MANAM));
+		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) {
+		manam_manam_unref (old);
+	}
+}
+
+static void
+manam_manam_class_init (ManamManamClass * klass,
+                        gpointer klass_data)
+{
+	manam_manam_parent_class = g_type_class_peek_parent (klass);
+	((ManamManamClass *) klass)->finalize = manam_manam_finalize;
+}
+
+static void
+manam_manam_instance_init (ManamManam * self,
+                           gpointer klass)
+{
+	self->ref_count = 1;
+}
+
+static void
+manam_manam_finalize (ManamManam * obj)
+{
+	ManamManam * self;
+	self = G_TYPE_CHECK_INSTANCE_CAST (obj, MANAM_TYPE_MANAM, ManamManam);
+	g_signal_handlers_destroy (self);
+}
+
+static GType
+manam_manam_get_type_once (void)
+{
+	static const GTypeValueTable g_define_type_value_table = { manam_value_manam_init, manam_value_manam_free_value, manam_value_manam_copy_value, manam_value_manam_peek_pointer, "p", manam_value_manam_collect_value, "p", manam_value_manam_lcopy_value };
+	static const GTypeInfo g_define_type_info = { sizeof (ManamManamClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) manam_manam_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ManamManam), 0, (GInstanceInitFunc) manam_manam_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 manam_manam_type_id;
+	manam_manam_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ManamManam", &g_define_type_info, &g_define_type_fundamental_info, 0);
+	return manam_manam_type_id;
+}
+
+GType
+manam_manam_get_type (void)
+{
+	static volatile gsize manam_manam_type_id__volatile = 0;
+	if (g_once_init_enter (&manam_manam_type_id__volatile)) {
+		GType manam_manam_type_id;
+		manam_manam_type_id = manam_manam_get_type_once ();
+		g_once_init_leave (&manam_manam_type_id__volatile, manam_manam_type_id);
+	}
+	return manam_manam_type_id__volatile;
+}
+
+gpointer
+manam_manam_ref (gpointer instance)
+{
+	ManamManam * self;
+	self = instance;
+	g_atomic_int_inc (&self->ref_count);
+	return instance;
+}
+
+void
+manam_manam_unref (gpointer instance)
+{
+	ManamManam * self;
+	self = instance;
+	if (g_atomic_int_dec_and_test (&self->ref_count)) {
+		MANAM_MANAM_GET_CLASS (self)->finalize (self);
+		g_type_free_instance ((GTypeInstance *) self);
+	}
+}
+
+void
+manam_foo_bar (void)
+{
+}
+
+ManamFoo*
+manam_foo_construct (GType object_type)
+{
+	ManamFoo* self = NULL;
+	self = (ManamFoo*) g_type_create_instance (object_type);
+	return self;
+}
+
+ManamFoo*
+manam_foo_new (void)
+{
+	return manam_foo_construct (MANAM_TYPE_FOO);
+}
+
+static void
+manam_value_foo_init (GValue* value)
+{
+	value->data[0].v_pointer = NULL;
+}
+
+static void
+manam_value_foo_free_value (GValue* value)
+{
+	if (value->data[0].v_pointer) {
+		manam_foo_unref (value->data[0].v_pointer);
+	}
+}
+
+static void
+manam_value_foo_copy_value (const GValue* src_value,
+                            GValue* dest_value)
+{
+	if (src_value->data[0].v_pointer) {
+		dest_value->data[0].v_pointer = manam_foo_ref (src_value->data[0].v_pointer);
+	} else {
+		dest_value->data[0].v_pointer = NULL;
+	}
+}
+
+static gpointer
+manam_value_foo_peek_pointer (const GValue* value)
+{
+	return value->data[0].v_pointer;
+}
+
+static gchar*
+manam_value_foo_collect_value (GValue* value,
+                               guint n_collect_values,
+                               GTypeCValue* collect_values,
+                               guint collect_flags)
+{
+	if (collect_values[0].v_pointer) {
+		ManamFoo * 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 = manam_foo_ref (object);
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	return NULL;
+}
+
+static gchar*
+manam_value_foo_lcopy_value (const GValue* value,
+                             guint n_collect_values,
+                             GTypeCValue* collect_values,
+                             guint collect_flags)
+{
+	ManamFoo ** 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 = manam_foo_ref (value->data[0].v_pointer);
+	}
+	return NULL;
+}
+
+GParamSpec*
+manam_param_spec_foo (const gchar* name,
+                      const gchar* nick,
+                      const gchar* blurb,
+                      GType object_type,
+                      GParamFlags flags)
+{
+	ManamParamSpecFoo* spec;
+	g_return_val_if_fail (g_type_is_a (object_type, MANAM_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
+manam_value_get_foo (const GValue* value)
+{
+	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MANAM_TYPE_FOO), NULL);
+	return value->data[0].v_pointer;
+}
+
+void
+manam_value_set_foo (GValue* value,
+                     gpointer v_object)
+{
+	ManamFoo * old;
+	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MANAM_TYPE_FOO));
+	old = value->data[0].v_pointer;
+	if (v_object) {
+		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MANAM_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;
+		manam_foo_ref (value->data[0].v_pointer);
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	if (old) {
+		manam_foo_unref (old);
+	}
+}
+
+void
+manam_value_take_foo (GValue* value,
+                      gpointer v_object)
+{
+	ManamFoo * old;
+	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, MANAM_TYPE_FOO));
+	old = value->data[0].v_pointer;
+	if (v_object) {
+		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, MANAM_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) {
+		manam_foo_unref (old);
+	}
+}
+
+static void
+manam_foo_class_init (ManamFooClass * klass,
+                      gpointer klass_data)
+{
+	manam_foo_parent_class = g_type_class_peek_parent (klass);
+	((ManamFooClass *) klass)->finalize = manam_foo_finalize;
+}
+
+static void
+manam_foo_instance_init (ManamFoo * self,
+                         gpointer klass)
+{
+	self->ref_count = 1;
+}
+
+static void
+manam_foo_finalize (ManamFoo * obj)
+{
+	ManamFoo * self;
+	self = G_TYPE_CHECK_INSTANCE_CAST (obj, MANAM_TYPE_FOO, ManamFoo);
+	g_signal_handlers_destroy (self);
+}
+
+static GType
+manam_foo_get_type_once (void)
+{
+	static const GTypeValueTable g_define_type_value_table = { manam_value_foo_init, manam_value_foo_free_value, manam_value_foo_copy_value, manam_value_foo_peek_pointer, "p", manam_value_foo_collect_value, "p", manam_value_foo_lcopy_value };
+	static const GTypeInfo g_define_type_info = { sizeof (ManamFooClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) manam_foo_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ManamFoo), 0, (GInstanceInitFunc) manam_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 manam_foo_type_id;
+	manam_foo_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ManamFoo", &g_define_type_info, &g_define_type_fundamental_info, 0);
+	return manam_foo_type_id;
+}
+
+GType
+manam_foo_get_type (void)
+{
+	static volatile gsize manam_foo_type_id__volatile = 0;
+	if (g_once_init_enter (&manam_foo_type_id__volatile)) {
+		GType manam_foo_type_id;
+		manam_foo_type_id = manam_foo_get_type_once ();
+		g_once_init_leave (&manam_foo_type_id__volatile, manam_foo_type_id);
+	}
+	return manam_foo_type_id__volatile;
+}
+
+gpointer
+manam_foo_ref (gpointer instance)
+{
+	ManamFoo * self;
+	self = instance;
+	g_atomic_int_inc (&self->ref_count);
+	return instance;
+}
+
+void
+manam_foo_unref (gpointer instance)
+{
+	ManamFoo * self;
+	self = instance;
+	if (g_atomic_int_dec_and_test (&self->ref_count)) {
+		MANAM_FOO_GET_CLASS (self)->finalize (self);
+		g_type_free_instance ((GTypeInstance *) self);
+	}
+}
+
+static void
+manam_main (void)
+{
+	ManamFoo* foo = NULL;
+	ManamFoo* _tmp0_;
+	_tmp0_ = manam_foo_new ();
+	foo = _tmp0_;
+	manam_foo_bar ();
+	_manam_foo_unref0 (foo);
+}
+
+int
+main (int argc,
+      char ** argv)
+{
+	manam_main ();
+	return 0;
+}
+
diff --git a/tests/semantic/member-access-static-with-instance.c-expected b/tests/semantic/member-access-static-with-instance.c-expected
new file mode 100644
index 000000000..e73423aa5
--- /dev/null
+++ b/tests/semantic/member-access-static-with-instance.c-expected
@@ -0,0 +1,87 @@
+/* semantic_member_access_static_with_instance.c generated by valac, the Vala compiler
+ * generated from semantic_member_access_static_with_instance.vala, do not modify */
+
+#include <glib-object.h>
+#include <glib.h>
+#include <string.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_FOO (foo_get_type ())
+typedef struct _Foo Foo;
+#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 _Foo {
+	gint i;
+};
+
+VALA_EXTERN Foo foo_static_field;
+Foo foo_static_field = {0};
+
+VALA_EXTERN GType foo_get_type (void) G_GNUC_CONST ;
+VALA_EXTERN Foo* foo_dup (const Foo* self);
+VALA_EXTERN void foo_free (Foo* self);
+#define FOO_FOO 23
+#define BAR FOO_FOO
+static void _vala_main (void);
+
+Foo*
+foo_dup (const Foo* self)
+{
+	Foo* dup;
+	dup = g_new0 (Foo, 1);
+	memcpy (dup, self, sizeof (Foo));
+	return dup;
+}
+
+void
+foo_free (Foo* self)
+{
+	g_free (self);
+}
+
+static GType
+foo_get_type_once (void)
+{
+	GType foo_type_id;
+	foo_type_id = g_boxed_type_register_static ("Foo", (GBoxedCopyFunc) foo_dup, (GBoxedFreeFunc) foo_free);
+	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;
+}
+
+static void
+_vala_main (void)
+{
+	_vala_assert (BAR == 23, "BAR == 23");
+}
+
+int
+main (int argc,
+      char ** argv)
+{
+	_vala_main ();
+	return 0;
+}
+
diff --git a/tests/semantic/member-access-transformed-qualified.c-expected b/tests/semantic/member-access-transformed-qualified.c-expected
new file mode 100644
index 000000000..9433c599e
--- /dev/null
+++ b/tests/semantic/member-access-transformed-qualified.c-expected
@@ -0,0 +1,308 @@
+/* semantic_member_access_transformed_qualified.c generated by valac, the Vala compiler
+ * generated from semantic_member_access_transformed_qualified.vala, do not modify */
+
+#include <glib.h>
+#include <glib-object.h>
+#include <gobject/gvaluecollector.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 FOO_MANAM_TYPE_FOO (foo_manam_foo_get_type ())
+#define FOO_MANAM_FOO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FOO_MANAM_TYPE_FOO, FooManamFoo))
+#define FOO_MANAM_FOO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), FOO_MANAM_TYPE_FOO, FooManamFooClass))
+#define FOO_MANAM_IS_FOO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FOO_MANAM_TYPE_FOO))
+#define FOO_MANAM_IS_FOO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), FOO_MANAM_TYPE_FOO))
+#define FOO_MANAM_FOO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), FOO_MANAM_TYPE_FOO, FooManamFooClass))
+
+typedef struct _FooManamFoo FooManamFoo;
+typedef struct _FooManamFooClass FooManamFooClass;
+typedef struct _FooManamFooPrivate FooManamFooPrivate;
+typedef struct _FooManamParamSpecFoo FooManamParamSpecFoo;
+#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 _FooManamFoo {
+	GTypeInstance parent_instance;
+	volatile int ref_count;
+	FooManamFooPrivate * priv;
+};
+
+struct _FooManamFooClass {
+	GTypeClass parent_class;
+	void (*finalize) (FooManamFoo *self);
+};
+
+struct _FooManamParamSpecFoo {
+	GParamSpec parent_instance;
+};
+
+VALA_EXTERN gint foo_bar_bar;
+gint foo_bar_bar = 23;
+static gpointer foo_manam_foo_parent_class = NULL;
+
+VALA_EXTERN gpointer foo_manam_foo_ref (gpointer instance);
+VALA_EXTERN void foo_manam_foo_unref (gpointer instance);
+VALA_EXTERN GParamSpec* foo_manam_param_spec_foo (const gchar* name,
+                                      const gchar* nick,
+                                      const gchar* blurb,
+                                      GType object_type,
+                                      GParamFlags flags);
+VALA_EXTERN void foo_manam_value_set_foo (GValue* value,
+                              gpointer v_object);
+VALA_EXTERN void foo_manam_value_take_foo (GValue* value,
+                               gpointer v_object);
+VALA_EXTERN gpointer foo_manam_value_get_foo (const GValue* value);
+VALA_EXTERN GType foo_manam_foo_get_type (void) G_GNUC_CONST ;
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (FooManamFoo, foo_manam_foo_unref)
+VALA_EXTERN void foo_manam_foo_faz (void);
+VALA_EXTERN FooManamFoo* foo_manam_foo_new (void);
+VALA_EXTERN FooManamFoo* foo_manam_foo_construct (GType object_type);
+static void foo_manam_foo_finalize (FooManamFoo * obj);
+static GType foo_manam_foo_get_type_once (void);
+static void _vala_main (void);
+
+void
+foo_manam_foo_faz (void)
+{
+	foo_bar_bar = 42;
+}
+
+FooManamFoo*
+foo_manam_foo_construct (GType object_type)
+{
+	FooManamFoo* self = NULL;
+	self = (FooManamFoo*) g_type_create_instance (object_type);
+	return self;
+}
+
+FooManamFoo*
+foo_manam_foo_new (void)
+{
+	return foo_manam_foo_construct (FOO_MANAM_TYPE_FOO);
+}
+
+static void
+foo_manam_value_foo_init (GValue* value)
+{
+	value->data[0].v_pointer = NULL;
+}
+
+static void
+foo_manam_value_foo_free_value (GValue* value)
+{
+	if (value->data[0].v_pointer) {
+		foo_manam_foo_unref (value->data[0].v_pointer);
+	}
+}
+
+static void
+foo_manam_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_manam_foo_ref (src_value->data[0].v_pointer);
+	} else {
+		dest_value->data[0].v_pointer = NULL;
+	}
+}
+
+static gpointer
+foo_manam_value_foo_peek_pointer (const GValue* value)
+{
+	return value->data[0].v_pointer;
+}
+
+static gchar*
+foo_manam_value_foo_collect_value (GValue* value,
+                                   guint n_collect_values,
+                                   GTypeCValue* collect_values,
+                                   guint collect_flags)
+{
+	if (collect_values[0].v_pointer) {
+		FooManamFoo * 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_manam_foo_ref (object);
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	return NULL;
+}
+
+static gchar*
+foo_manam_value_foo_lcopy_value (const GValue* value,
+                                 guint n_collect_values,
+                                 GTypeCValue* collect_values,
+                                 guint collect_flags)
+{
+	FooManamFoo ** 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_manam_foo_ref (value->data[0].v_pointer);
+	}
+	return NULL;
+}
+
+GParamSpec*
+foo_manam_param_spec_foo (const gchar* name,
+                          const gchar* nick,
+                          const gchar* blurb,
+                          GType object_type,
+                          GParamFlags flags)
+{
+	FooManamParamSpecFoo* spec;
+	g_return_val_if_fail (g_type_is_a (object_type, FOO_MANAM_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
+foo_manam_value_get_foo (const GValue* value)
+{
+	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, FOO_MANAM_TYPE_FOO), NULL);
+	return value->data[0].v_pointer;
+}
+
+void
+foo_manam_value_set_foo (GValue* value,
+                         gpointer v_object)
+{
+	FooManamFoo * old;
+	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, FOO_MANAM_TYPE_FOO));
+	old = value->data[0].v_pointer;
+	if (v_object) {
+		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, FOO_MANAM_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_manam_foo_ref (value->data[0].v_pointer);
+	} else {
+		value->data[0].v_pointer = NULL;
+	}
+	if (old) {
+		foo_manam_foo_unref (old);
+	}
+}
+
+void
+foo_manam_value_take_foo (GValue* value,
+                          gpointer v_object)
+{
+	FooManamFoo * old;
+	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, FOO_MANAM_TYPE_FOO));
+	old = value->data[0].v_pointer;
+	if (v_object) {
+		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, FOO_MANAM_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_manam_foo_unref (old);
+	}
+}
+
+static void
+foo_manam_foo_class_init (FooManamFooClass * klass,
+                          gpointer klass_data)
+{
+	foo_manam_foo_parent_class = g_type_class_peek_parent (klass);
+	((FooManamFooClass *) klass)->finalize = foo_manam_foo_finalize;
+}
+
+static void
+foo_manam_foo_instance_init (FooManamFoo * self,
+                             gpointer klass)
+{
+	self->ref_count = 1;
+}
+
+static void
+foo_manam_foo_finalize (FooManamFoo * obj)
+{
+	FooManamFoo * self;
+	self = G_TYPE_CHECK_INSTANCE_CAST (obj, FOO_MANAM_TYPE_FOO, FooManamFoo);
+	g_signal_handlers_destroy (self);
+}
+
+static GType
+foo_manam_foo_get_type_once (void)
+{
+	static const GTypeValueTable g_define_type_value_table = { foo_manam_value_foo_init, foo_manam_value_foo_free_value, foo_manam_value_foo_copy_value, foo_manam_value_foo_peek_pointer, "p", foo_manam_value_foo_collect_value, "p", foo_manam_value_foo_lcopy_value };
+	static const GTypeInfo g_define_type_info = { sizeof (FooManamFooClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) foo_manam_foo_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (FooManamFoo), 0, (GInstanceInitFunc) foo_manam_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_manam_foo_type_id;
+	foo_manam_foo_type_id = g_type_register_fundamental (g_type_fundamental_next (), "FooManamFoo", &g_define_type_info, &g_define_type_fundamental_info, 0);
+	return foo_manam_foo_type_id;
+}
+
+GType
+foo_manam_foo_get_type (void)
+{
+	static volatile gsize foo_manam_foo_type_id__volatile = 0;
+	if (g_once_init_enter (&foo_manam_foo_type_id__volatile)) {
+		GType foo_manam_foo_type_id;
+		foo_manam_foo_type_id = foo_manam_foo_get_type_once ();
+		g_once_init_leave (&foo_manam_foo_type_id__volatile, foo_manam_foo_type_id);
+	}
+	return foo_manam_foo_type_id__volatile;
+}
+
+gpointer
+foo_manam_foo_ref (gpointer instance)
+{
+	FooManamFoo * self;
+	self = instance;
+	g_atomic_int_inc (&self->ref_count);
+	return instance;
+}
+
+void
+foo_manam_foo_unref (gpointer instance)
+{
+	FooManamFoo * self;
+	self = instance;
+	if (g_atomic_int_dec_and_test (&self->ref_count)) {
+		FOO_MANAM_FOO_GET_CLASS (self)->finalize (self);
+		g_type_free_instance ((GTypeInstance *) self);
+	}
+}
+
+static void
+_vala_main (void)
+{
+	_vala_assert (foo_bar_bar == 23, "bar == 23");
+	foo_manam_foo_faz ();
+	_vala_assert (foo_bar_bar == 42, "bar == 42");
+}
+
+int
+main (int argc,
+      char ** argv)
+{
+	_vala_main ();
+	return 0;
+}
+
diff --git a/tests/semantic/with-buildin.c-expected b/tests/semantic/with-buildin.c-expected
new file mode 100644
index 000000000..a0a15512d
--- /dev/null
+++ b/tests/semantic/with-buildin.c-expected
@@ -0,0 +1,33 @@
+/* semantic_with_buildin.c generated by valac, the Vala compiler
+ * generated from semantic_with_buildin.vala, do not modify */
+
+#include <stdio.h>
+#include <glib.h>
+
+#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);
+
+static void _vala_main (void);
+
+static void
+_vala_main (void)
+{
+	{
+		FILE* _tmp0_ = NULL;
+		FILE* _tmp1_;
+		_tmp1_ = stdout;
+		_tmp0_ = _tmp1_;
+		_vala_assert (!feof (_tmp0_), "!eof ()");
+	}
+}
+
+int
+main (int argc,
+      char ** argv)
+{
+	_vala_main ();
+	return 0;
+}
+
diff --git a/tests/semantic/with-compact.c-expected b/tests/semantic/with-compact.c-expected
new file mode 100644
index 000000000..aa892e239
--- /dev/null
+++ b/tests/semantic/with-compact.c-expected
@@ -0,0 +1,74 @@
+/* semantic_with_compact.c generated by valac, the Vala compiler
+ * generated from semantic_with_compact.vala, do not modify */
+
+#include <glib.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
+
+typedef struct _Foo Foo;
+#define _foo_free0(var) ((var == NULL) ? NULL : (var = (foo_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 _Foo {
+	gint i;
+};
+
+VALA_EXTERN void foo_free (Foo * self);
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (Foo, foo_free)
+static void foo_instance_init (Foo * self);
+VALA_EXTERN Foo* foo_new (void);
+static void _vala_main (void);
+
+Foo*
+foo_new (void)
+{
+	Foo* self;
+	self = g_slice_new0 (Foo);
+	foo_instance_init (self);
+	return self;
+}
+
+static void
+foo_instance_init (Foo * self)
+{
+}
+
+void
+foo_free (Foo * self)
+{
+	g_slice_free (Foo, self);
+}
+
+static void
+_vala_main (void)
+{
+	Foo* foo = NULL;
+	Foo* _tmp0_;
+	_tmp0_ = foo_new ();
+	foo = _tmp0_;
+	{
+		foo->i = 13;
+	}
+	_vala_assert (foo->i == 13, "foo.i == 13");
+	_foo_free0 (foo);
+}
+
+int
+main (int argc,
+      char ** argv)
+{
+	_vala_main ();
+	return 0;
+}
+
diff --git a/tests/semantic/with-declaration-cast-type.c-expected b/tests/semantic/with-declaration-cast-type.c-expected
new file mode 100644
index 000000000..95d83e04d
--- /dev/null
+++ b/tests/semantic/with-declaration-cast-type.c-expected
@@ -0,0 +1,373 @@
+/* semantic_with_declaration_cast_type.c generated by valac, the Vala compiler
+ * generated from semantic_with_declaration_cast_type.vala, do not modify */
+
+#include <glib-object.h>
+#include <gobject/gvaluecollector.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_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;
+
+#define TYPE_BAR (bar_get_type ())
+#define BAR(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_BAR, Bar))
+#define BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_BAR, BarClass))
+#define IS_BAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_BAR))
+#define IS_BAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_BAR))
+#define BAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_BAR, BarClass))
+
+typedef struct _Bar Bar;
+typedef struct _BarClass BarClass;
+typedef struct _BarPrivate BarPrivate;
+#define _foo_unref0(var) ((var == NULL) ? NULL : (var = (foo_unref (var), NULL)))
+
+struct _Foo {
+	GTypeInstance parent_instance;
+	volatile int ref_count;
+	FooPrivate * priv;
+};
+
+struct _FooClass {
+	GTypeClass parent_class;
+	void (*finalize) (Foo *self);
+};
+
+struct _ParamSpecFoo {
+	GParamSpec parent_instance;
+};
+
+struct _Bar {
+	Foo parent_instance;
+	BarPrivate * priv;
+};
+
+struct _BarClass {
+	FooClass parent_class;
+};
+
+static gpointer foo_parent_class = NULL;
+static gpointer bar_parent_class = NULL;
+
+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 GType bar_get_type (void) G_GNUC_CONST ;
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (Bar, foo_unref)
+VALA_EXTERN Bar* bar_new (void);
+VALA_EXTERN Bar* bar_construct (GType object_type);
+static GType bar_get_type_once (void);
+static void _vala_main (void);
+
+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)
+{
+	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);
+}
+
+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_construct (GType object_type)
+{
+	Bar* self = NULL;
+	self = (Bar*) foo_construct (object_type);
+	return self;
+}
+
+Bar*
+bar_new (void)
+{
+	return bar_construct (TYPE_BAR);
+}
+
+static void
+bar_class_init (BarClass * klass,
+                gpointer klass_data)
+{
+	bar_parent_class = g_type_class_peek_parent (klass);
+}
+
+static void
+bar_instance_init (Bar * self,
+                   gpointer klass)
+{
+}
+
+static GType
+bar_get_type_once (void)
+{
+	static const GTypeInfo g_define_type_info = { sizeof (BarClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) bar_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Bar), 0, (GInstanceInitFunc) bar_instance_init, NULL };
+	GType bar_type_id;
+	bar_type_id = g_type_register_static (TYPE_FOO, "Bar", &g_define_type_info, 0);
+	return bar_type_id;
+}
+
+GType
+bar_get_type (void)
+{
+	static volatile gsize bar_type_id__volatile = 0;
+	if (g_once_init_enter (&bar_type_id__volatile)) {
+		GType bar_type_id;
+		bar_type_id = bar_get_type_once ();
+		g_once_init_leave (&bar_type_id__volatile, bar_type_id);
+	}
+	return bar_type_id__volatile;
+}
+
+static void
+_vala_main (void)
+{
+	{
+		Foo* f = NULL;
+		Bar* _tmp0_;
+		_tmp0_ = bar_new ();
+		f = G_TYPE_CHECK_INSTANCE_CAST (_tmp0_, TYPE_FOO, Foo);
+		_foo_unref0 (f);
+	}
+}
+
+int
+main (int argc,
+      char ** argv)
+{
+	_vala_main ();
+	return 0;
+}
+
diff --git a/tests/semantic/with-declaration.c-expected b/tests/semantic/with-declaration.c-expected
new file mode 100644
index 000000000..3774c1bdc
--- /dev/null
+++ b/tests/semantic/with-declaration.c-expected
@@ -0,0 +1,356 @@
+/* semantic_with_declaration.c generated by valac, the Vala compiler
+ * generated from semantic_with_declaration.vala, do not modify */
+
+#include <glib-object.h>
+#include <glib.h>
+#include <gobject/gvaluecollector.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_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;
+#define _foo_unref0(var) ((var == NULL) ? NULL : (var = (foo_unref (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 _Foo {
+	GTypeInstance parent_instance;
+	volatile int ref_count;
+	FooPrivate * priv;
+	gint i;
+	gint j;
+};
+
+struct _FooClass {
+	GTypeClass parent_class;
+	void (*finalize) (Foo *self);
+};
+
+struct _ParamSpecFoo {
+	GParamSpec parent_instance;
+};
+
+static gpointer foo_parent_class = NULL;
+
+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);
+static void _vala_main (void);
+
+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)
+{
+	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);
+}
+
+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);
+	}
+}
+
+static gpointer
+_foo_ref0 (gpointer self)
+{
+	return self ? foo_ref (self) : NULL;
+}
+
+static void
+_vala_main (void)
+{
+	Foo* foo = NULL;
+	Foo* _tmp0_;
+	Foo* f = NULL;
+	Foo* _tmp7_;
+	_tmp0_ = foo_new ();
+	foo = _tmp0_;
+	{
+		foo->i = 10;
+	}
+	_vala_assert (foo->i == 10, "foo.i == 10");
+	{
+		Foo* f = NULL;
+		Foo* _tmp1_;
+		_tmp1_ = _foo_ref0 (foo);
+		f = _tmp1_;
+		f->i = 100;
+		f->j = 200;
+		_foo_unref0 (f);
+	}
+	_vala_assert (foo->i == 100, "foo.i == 100");
+	_vala_assert (foo->j == 200, "foo.j == 200");
+	{
+		Foo* f = NULL;
+		Foo* _tmp2_;
+		_tmp2_ = _foo_ref0 (foo);
+		f = _tmp2_;
+		f->i = 1000;
+		f->j = 2000;
+		_foo_unref0 (f);
+	}
+	_vala_assert (foo->i == 1000, "foo.i == 1000");
+	_vala_assert (foo->j == 2000, "foo.j == 2000");
+	{
+		Foo* _tmp3_ = NULL;
+		Foo* _tmp4_;
+		Foo* _tmp5_;
+		Foo* _tmp6_;
+		_tmp4_ = _foo_ref0 (foo);
+		_foo_unref0 (f);
+		f = _tmp4_;
+		_tmp5_ = f;
+		_tmp3_ = _tmp5_;
+		_tmp3_->i = 10000;
+		_tmp6_ = f;
+		_tmp6_->j = 20000;
+	}
+	_tmp7_ = f;
+	_vala_assert (_tmp7_->i == 10000, "f.i == 10000");
+	_vala_assert (foo->j == 20000, "foo.j == 20000");
+	_foo_unref0 (f);
+	_foo_unref0 (foo);
+}
+
+int
+main (int argc,
+      char ** argv)
+{
+	_vala_main ();
+	return 0;
+}
+
diff --git a/tests/semantic/with-dereferenced-pointer.c-expected b/tests/semantic/with-dereferenced-pointer.c-expected
new file mode 100644
index 000000000..616fc758d
--- /dev/null
+++ b/tests/semantic/with-dereferenced-pointer.c-expected
@@ -0,0 +1,311 @@
+/* semantic_with_dereferenced_pointer.c generated by valac, the Vala compiler
+ * generated from semantic_with_dereferenced_pointer.vala, do not modify */
+
+#include <glib-object.h>
+#include <glib.h>
+#include <gobject/gvaluecollector.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_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;
+#define _foo_unref0(var) ((var == NULL) ? NULL : (var = (foo_unref (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 _Foo {
+	GTypeInstance parent_instance;
+	volatile int ref_count;
+	FooPrivate * priv;
+	gint i;
+};
+
+struct _FooClass {
+	GTypeClass parent_class;
+	void (*finalize) (Foo *self);
+};
+
+struct _ParamSpecFoo {
+	GParamSpec parent_instance;
+};
+
+static gpointer foo_parent_class = NULL;
+
+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);
+static void _vala_main (void);
+
+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)
+{
+	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);
+}
+
+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);
+	}
+}
+
+static void
+_vala_main (void)
+{
+	Foo* f = NULL;
+	Foo* _tmp0_;
+	Foo** p = NULL;
+	_tmp0_ = foo_new ();
+	f = _tmp0_;
+	p = &f;
+	{
+		Foo* _tmp1_ = NULL;
+		_tmp1_ = *p;
+		G_TYPE_CHECK_INSTANCE_CAST (_tmp1_, TYPE_FOO, Foo)->i = 13;
+	}
+	_vala_assert (f->i == 13, "f.i == 13");
+	_foo_unref0 (f);
+}
+
+int
+main (int argc,
+      char ** argv)
+{
+	_vala_main ();
+	return 0;
+}
+
diff --git a/tests/semantic/with-enum-member.c-expected b/tests/semantic/with-enum-member.c-expected
new file mode 100644
index 000000000..a60d110d8
--- /dev/null
+++ b/tests/semantic/with-enum-member.c-expected
@@ -0,0 +1,62 @@
+/* semantic_with_enum_member.c generated by valac, the Vala compiler
+ * generated from semantic_with_enum_member.vala, do not modify */
+
+#include <glib-object.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
+
+typedef enum  {
+	FOO_ENUM_FIRST
+} FooEnum;
+
+#define TYPE_FOO_ENUM (foo_enum_get_type ())
+
+VALA_EXTERN GType foo_enum_get_type (void) G_GNUC_CONST ;
+static void _vala_main (void);
+
+static GType
+foo_enum_get_type_once (void)
+{
+	static const GEnumValue values[] = {{FOO_ENUM_FIRST, "FOO_ENUM_FIRST", "first"}, {0, NULL, NULL}};
+	GType foo_enum_type_id;
+	foo_enum_type_id = g_enum_register_static ("FooEnum", values);
+	return foo_enum_type_id;
+}
+
+GType
+foo_enum_get_type (void)
+{
+	static volatile gsize foo_enum_type_id__volatile = 0;
+	if (g_once_init_enter (&foo_enum_type_id__volatile)) {
+		GType foo_enum_type_id;
+		foo_enum_type_id = foo_enum_get_type_once ();
+		g_once_init_leave (&foo_enum_type_id__volatile, foo_enum_type_id);
+	}
+	return foo_enum_type_id__volatile;
+}
+
+static void
+_vala_main (void)
+{
+	{
+		FooEnum _tmp0_ = 0;
+		_tmp0_ = FOO_ENUM_FIRST;
+	}
+}
+
+int
+main (int argc,
+      char ** argv)
+{
+	_vala_main ();
+	return 0;
+}
+
diff --git a/tests/semantic/with-null.c-expected b/tests/semantic/with-null.c-expected
new file mode 100644
index 000000000..452d2995c
--- /dev/null
+++ b/tests/semantic/with-null.c-expected
@@ -0,0 +1,300 @@
+/* semantic_with_null.c generated by valac, the Vala compiler
+ * generated from semantic_with_null.vala, do not modify */
+
+#include <glib-object.h>
+#include <glib.h>
+#include <gobject/gvaluecollector.h>
+#include <stdlib.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_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;
+
+struct _Foo {
+	GTypeInstance parent_instance;
+	volatile int ref_count;
+	FooPrivate * priv;
+	gint i;
+};
+
+struct _FooClass {
+	GTypeClass parent_class;
+	void (*finalize) (Foo *self);
+};
+
+struct _ParamSpecFoo {
+	GParamSpec parent_instance;
+};
+
+static gpointer foo_parent_class = NULL;
+
+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);
+static void _vala_main (void);
+
+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)
+{
+	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);
+}
+
+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);
+	}
+}
+
+static void
+_vala_main (void)
+{
+	Foo* f = NULL;
+	f = NULL;
+	exit (0);
+	{
+		f->i = 7;
+	}
+}
+
+int
+main (int argc,
+      char ** argv)
+{
+	_vala_main ();
+	return 0;
+}
+
diff --git a/tests/semantic/with-string.c-expected b/tests/semantic/with-string.c-expected
new file mode 100644
index 000000000..461a6966e
--- /dev/null
+++ b/tests/semantic/with-string.c-expected
@@ -0,0 +1,52 @@
+/* semantic_with_string.c generated by valac, the Vala compiler
+ * generated from semantic_with_string.vala, do not modify */
+
+#include <stdlib.h>
+#include <string.h>
+#include <glib.h>
+
+#define _g_free0(var) (var = (g_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);
+
+static void _vala_main (void);
+
+static gchar*
+string_chomp (const gchar* self)
+{
+	gchar* _result_ = NULL;
+	gchar* _tmp0_;
+	gchar* result = NULL;
+	g_return_val_if_fail (self != NULL, NULL);
+	_tmp0_ = g_strdup (self);
+	_result_ = _tmp0_;
+	g_strchomp (_result_);
+	result = _result_;
+	return result;
+}
+
+static void
+_vala_main (void)
+{
+	{
+		const gchar* _tmp0_ = NULL;
+		gchar* _tmp1_;
+		gchar* _tmp2_;
+		_tmp0_ = "string ";
+		_tmp1_ = string_chomp (_tmp0_);
+		_tmp2_ = _tmp1_;
+		_vala_assert (g_strcmp0 (_tmp2_, "string") == 0, "chomp () == \"string\"");
+		_g_free0 (_tmp2_);
+	}
+}
+
+int
+main (int argc,
+      char ** argv)
+{
+	_vala_main ();
+	return 0;
+}
+
diff --git a/tests/semantic/with-value.c-expected b/tests/semantic/with-value.c-expected
new file mode 100644
index 000000000..1f09b3072
--- /dev/null
+++ b/tests/semantic/with-value.c-expected
@@ -0,0 +1,39 @@
+/* semantic_with_value.c generated by valac, the Vala compiler
+ * generated from semantic_with_value.vala, do not modify */
+
+#include <glib.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define _g_free0(var) (var = (g_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);
+
+static void _vala_main (void);
+
+static void
+_vala_main (void)
+{
+	gint i = 0;
+	gchar* s = NULL;
+	i = 0;
+	{
+		gchar* _tmp0_;
+		_tmp0_ = g_strdup_printf ("%i", i);
+		_g_free0 (s);
+		s = _tmp0_;
+	}
+	_vala_assert (g_strcmp0 (s, "0") == 0, "s == \"0\"");
+	_g_free0 (s);
+}
+
+int
+main (int argc,
+      char ** argv)
+{
+	_vala_main ();
+	return 0;
+}
+