codegen: Use a dedicated EmitContext for _variant_get*() functions

8 files changed, 618 insertions, 616 deletions

diff --git a/codegen/valagvariantmodule.vala b/codegen/valagvariantmodule.vala
index 9f53ca010..be13d35b9 100644
--- a/codegen/valagvariantmodule.vala
+++ b/codegen/valagvariantmodule.vala
@@ -158,6 +158,7 @@ public class Vala.GVariantModule : GValueModule {
 			ccode.add_expression (ccall);
 		}
 
+		push_context (new EmitContext ());
 		push_function (cfunc);
 
 		CCodeExpression type_expr = null;
@@ -217,6 +218,7 @@ public class Vala.GVariantModule : GValueModule {
 		}
 
 		pop_function ();
+		pop_context ();
 
 		cfile.add_function_declaration (cfunc);
 		cfile.add_function (cfunc);
diff --git a/tests/basic-types/bug772426.c-expected b/tests/basic-types/bug772426.c-expected
index c9f08aa2a..07c92c0d1 100644
--- a/tests/basic-types/bug772426.c-expected
+++ b/tests/basic-types/bug772426.c-expected
@@ -44,12 +44,12 @@ static guint8*
 _variant_get1 (GVariant* value,
                gint* result_length1)
 {
-	gsize _tmp4__length;
-	guint8* _tmp4_;
-	_tmp4__length = g_variant_get_size (value);
-	_tmp4_ = _vala_memdup2 (g_variant_get_data (value), _tmp4__length);
-	*result_length1 = _tmp4__length;
-	return _tmp4_;
+	gsize _tmp0__length;
+	guint8* _tmp0_;
+	_tmp0__length = g_variant_get_size (value);
+	_tmp0_ = _vala_memdup2 (g_variant_get_data (value), _tmp0__length);
+	*result_length1 = _tmp0__length;
+	return _tmp0_;
 }
 
 static void
diff --git a/tests/basic-types/gvariants-unboxing-safe.c-expected b/tests/basic-types/gvariants-unboxing-safe.c-expected
index d7ce38f8c..acd53d71c 100644
--- a/tests/basic-types/gvariants-unboxing-safe.c-expected
+++ b/tests/basic-types/gvariants-unboxing-safe.c-expected
@@ -147,11 +147,11 @@ static gboolean*
 _variant_get1 (GVariant* value)
 {
 	if (value && g_variant_is_of_type (value, G_VARIANT_TYPE_BOOLEAN)) {
-		gboolean _tmp3_;
-		gboolean* _tmp4_;
-		_tmp3_ = g_variant_get_boolean (value);
-		_tmp4_ = __bool_dup0 (&_tmp3_);
-		return _tmp4_;
+		gboolean _tmp0_;
+		gboolean* _tmp1_;
+		_tmp0_ = g_variant_get_boolean (value);
+		_tmp1_ = __bool_dup0 (&_tmp0_);
+		return _tmp1_;
 	} else {
 		return NULL;
 	}
@@ -176,11 +176,11 @@ static gint16*
 _variant_get2 (GVariant* value)
 {
 	if (value && g_variant_is_of_type (value, G_VARIANT_TYPE_INT16)) {
-		gint16 _tmp7_;
-		gint16* _tmp8_;
-		_tmp7_ = g_variant_get_int16 (value);
-		_tmp8_ = __int16_dup0 (&_tmp7_);
-		return _tmp8_;
+		gint16 _tmp0_;
+		gint16* _tmp1_;
+		_tmp0_ = g_variant_get_int16 (value);
+		_tmp1_ = __int16_dup0 (&_tmp0_);
+		return _tmp1_;
 	} else {
 		return NULL;
 	}
@@ -205,11 +205,11 @@ static gint32*
 _variant_get3 (GVariant* value)
 {
 	if (value && g_variant_is_of_type (value, G_VARIANT_TYPE_INT32)) {
-		gint32 _tmp11_;
-		gint32* _tmp12_;
-		_tmp11_ = g_variant_get_int32 (value);
-		_tmp12_ = __int32_dup0 (&_tmp11_);
-		return _tmp12_;
+		gint32 _tmp0_;
+		gint32* _tmp1_;
+		_tmp0_ = g_variant_get_int32 (value);
+		_tmp1_ = __int32_dup0 (&_tmp0_);
+		return _tmp1_;
 	} else {
 		return NULL;
 	}
@@ -245,11 +245,11 @@ static gboolean*
 _variant_get5 (GVariant* value)
 {
 	if (value && g_variant_is_of_type (value, G_VARIANT_TYPE_BOOLEAN)) {
-		gboolean _tmp19_;
-		gboolean* _tmp20_;
-		_tmp19_ = g_variant_get_boolean (value);
-		_tmp20_ = __bool_dup0 (&_tmp19_);
-		return _tmp20_;
+		gboolean _tmp0_;
+		gboolean* _tmp1_;
+		_tmp0_ = g_variant_get_boolean (value);
+		_tmp1_ = __bool_dup0 (&_tmp0_);
+		return _tmp1_;
 	} else {
 		return NULL;
 	}
@@ -275,11 +275,11 @@ static gint32*
 _variant_get6 (GVariant* value)
 {
 	if (value && g_variant_is_of_type (value, G_VARIANT_TYPE_INT32)) {
-		gint32 _tmp24_;
-		gint32* _tmp25_;
-		_tmp24_ = g_variant_get_int32 (value);
-		_tmp25_ = __int32_dup0 (&_tmp24_);
-		return _tmp25_;
+		gint32 _tmp0_;
+		gint32* _tmp1_;
+		_tmp0_ = g_variant_get_int32 (value);
+		_tmp1_ = __int32_dup0 (&_tmp0_);
+		return _tmp1_;
 	} else {
 		return NULL;
 	}
@@ -289,38 +289,38 @@ static gchar**
 _variant_get7 (GVariant* value,
                gint* result_length1)
 {
-	GVariantType* _tmp34_ = NULL;
-	_tmp34_ = g_variant_type_new ("as");
-	if (value && g_variant_is_of_type (value, _tmp34_)) {
-		gchar** _tmp35_;
-		gint _tmp35__length;
-		gint _tmp35__size;
-		gint _tmp35__length1;
-		GVariantIter _tmp36_;
-		GVariant* _tmp37_;
-		gchar** _tmp38_;
-		gint _tmp38__length1;
-		_tmp35_ = g_new (gchar*, 5);
-		_tmp35__length = 0;
-		_tmp35__size = 4;
-		_tmp35__length1 = 0;
-		g_variant_iter_init (&_tmp36_, value);
-		for (; (_tmp37_ = g_variant_iter_next_value (&_tmp36_)) != NULL; _tmp35__length1++) {
-			if (_tmp35__size == _tmp35__length) {
-				_tmp35__size = 2 * _tmp35__size;
-				_tmp35_ = g_renew (gchar*, _tmp35_, _tmp35__size + 1);
+	GVariantType* _tmp0_ = NULL;
+	_tmp0_ = g_variant_type_new ("as");
+	if (value && g_variant_is_of_type (value, _tmp0_)) {
+		gchar** _tmp1_;
+		gint _tmp1__length;
+		gint _tmp1__size;
+		gint _tmp1__length1;
+		GVariantIter _tmp2_;
+		GVariant* _tmp3_;
+		gchar** _tmp4_;
+		gint _tmp4__length1;
+		_tmp1_ = g_new (gchar*, 5);
+		_tmp1__length = 0;
+		_tmp1__size = 4;
+		_tmp1__length1 = 0;
+		g_variant_iter_init (&_tmp2_, value);
+		for (; (_tmp3_ = g_variant_iter_next_value (&_tmp2_)) != NULL; _tmp1__length1++) {
+			if (_tmp1__size == _tmp1__length) {
+				_tmp1__size = 2 * _tmp1__size;
+				_tmp1_ = g_renew (gchar*, _tmp1_, _tmp1__size + 1);
 			}
-			_tmp35_[_tmp35__length++] = g_variant_dup_string (_tmp37_, NULL);
-			g_variant_unref (_tmp37_);
+			_tmp1_[_tmp1__length++] = g_variant_dup_string (_tmp3_, NULL);
+			g_variant_unref (_tmp3_);
 		}
-		*result_length1 = _tmp35__length1;
-		_tmp35_[_tmp35__length] = NULL;
-		g_variant_type_free (_tmp34_);
-		_tmp38_ = _tmp35_;
-		_tmp38__length1 = -1;
-		return _tmp38_;
+		*result_length1 = _tmp1__length1;
+		_tmp1_[_tmp1__length] = NULL;
+		g_variant_type_free (_tmp0_);
+		_tmp4_ = _tmp1_;
+		_tmp4__length1 = -1;
+		return _tmp4_;
 	} else {
-		g_variant_type_free (_tmp34_);
+		g_variant_type_free (_tmp0_);
 		return NULL;
 	}
 }
@@ -328,63 +328,63 @@ _variant_get7 (GVariant* value,
 static GVariant*
 _variant_new1 (Foo value)
 {
-	GVariantBuilder _tmp43_;
-	g_variant_builder_init (&_tmp43_, G_VARIANT_TYPE_TUPLE);
-	g_variant_builder_add_value (&_tmp43_, g_variant_new_string (value.s));
-	g_variant_builder_add_value (&_tmp43_, g_variant_new_uint64 (value.u64));
-	g_variant_builder_add_value (&_tmp43_, g_variant_new_boolean (value.b));
-	return g_variant_ref_sink (g_variant_builder_end (&_tmp43_));
+	GVariantBuilder _tmp28_;
+	g_variant_builder_init (&_tmp28_, G_VARIANT_TYPE_TUPLE);
+	g_variant_builder_add_value (&_tmp28_, g_variant_new_string (value.s));
+	g_variant_builder_add_value (&_tmp28_, g_variant_new_uint64 (value.u64));
+	g_variant_builder_add_value (&_tmp28_, g_variant_new_boolean (value.b));
+	return g_variant_ref_sink (g_variant_builder_end (&_tmp28_));
 }
 
 static void
 _variant_get8 (GVariant* value,
                Foo * result)
 {
-	Foo _tmp49_;
-	GVariantIter _tmp50_;
-	GVariant* _tmp51_;
-	GVariant* _tmp52_;
-	GVariant* _tmp53_;
-	g_variant_iter_init (&_tmp50_, value);
-	_tmp51_ = g_variant_iter_next_value (&_tmp50_);
-	_tmp49_.s = g_variant_dup_string (_tmp51_, NULL);
-	g_variant_unref (_tmp51_);
-	_tmp52_ = g_variant_iter_next_value (&_tmp50_);
-	_tmp49_.u64 = g_variant_get_uint64 (_tmp52_);
-	g_variant_unref (_tmp52_);
-	_tmp53_ = g_variant_iter_next_value (&_tmp50_);
-	_tmp49_.b = g_variant_get_boolean (_tmp53_);
-	g_variant_unref (_tmp53_);
-	*result = _tmp49_;
+	Foo _tmp0_;
+	GVariantIter _tmp1_;
+	GVariant* _tmp2_;
+	GVariant* _tmp3_;
+	GVariant* _tmp4_;
+	g_variant_iter_init (&_tmp1_, value);
+	_tmp2_ = g_variant_iter_next_value (&_tmp1_);
+	_tmp0_.s = g_variant_dup_string (_tmp2_, NULL);
+	g_variant_unref (_tmp2_);
+	_tmp3_ = g_variant_iter_next_value (&_tmp1_);
+	_tmp0_.u64 = g_variant_get_uint64 (_tmp3_);
+	g_variant_unref (_tmp3_);
+	_tmp4_ = g_variant_iter_next_value (&_tmp1_);
+	_tmp0_.b = g_variant_get_boolean (_tmp4_);
+	g_variant_unref (_tmp4_);
+	*result = _tmp0_;
 }
 
 static Foo*
 _variant_get9 (GVariant* value)
 {
-	GVariantType* _tmp60_ = NULL;
-	_tmp60_ = g_variant_type_new ("(stb)");
-	if (value && g_variant_is_of_type (value, _tmp60_)) {
-		Foo _tmp61_;
-		GVariantIter _tmp62_;
-		GVariant* _tmp63_;
-		GVariant* _tmp64_;
-		GVariant* _tmp65_;
-		Foo* _tmp66_;
-		g_variant_iter_init (&_tmp62_, value);
-		_tmp63_ = g_variant_iter_next_value (&_tmp62_);
-		_tmp61_.s = g_variant_dup_string (_tmp63_, NULL);
-		g_variant_unref (_tmp63_);
-		_tmp64_ = g_variant_iter_next_value (&_tmp62_);
-		_tmp61_.u64 = g_variant_get_uint64 (_tmp64_);
-		g_variant_unref (_tmp64_);
-		_tmp65_ = g_variant_iter_next_value (&_tmp62_);
-		_tmp61_.b = g_variant_get_boolean (_tmp65_);
-		g_variant_unref (_tmp65_);
-		g_variant_type_free (_tmp60_);
-		_tmp66_ = _vala_memdup2 (&_tmp61_, sizeof (Foo));
-		return _tmp66_;
+	GVariantType* _tmp0_ = NULL;
+	_tmp0_ = g_variant_type_new ("(stb)");
+	if (value && g_variant_is_of_type (value, _tmp0_)) {
+		Foo _tmp1_;
+		GVariantIter _tmp2_;
+		GVariant* _tmp3_;
+		GVariant* _tmp4_;
+		GVariant* _tmp5_;
+		Foo* _tmp6_;
+		g_variant_iter_init (&_tmp2_, value);
+		_tmp3_ = g_variant_iter_next_value (&_tmp2_);
+		_tmp1_.s = g_variant_dup_string (_tmp3_, NULL);
+		g_variant_unref (_tmp3_);
+		_tmp4_ = g_variant_iter_next_value (&_tmp2_);
+		_tmp1_.u64 = g_variant_get_uint64 (_tmp4_);
+		g_variant_unref (_tmp4_);
+		_tmp5_ = g_variant_iter_next_value (&_tmp2_);
+		_tmp1_.b = g_variant_get_boolean (_tmp5_);
+		g_variant_unref (_tmp5_);
+		g_variant_type_free (_tmp0_);
+		_tmp6_ = _vala_memdup2 (&_tmp1_, sizeof (Foo));
+		return _tmp6_;
 	} else {
-		g_variant_type_free (_tmp60_);
+		g_variant_type_free (_tmp0_);
 		return NULL;
 	}
 }
@@ -398,43 +398,43 @@ _g_free0_ (gpointer var)
 static GVariant*
 _variant_new2 (GHashTable* value)
 {
-	GVariantBuilder _tmp75_;
-	GHashTableIter _tmp76_;
-	gpointer _tmp77_;
-	gpointer _tmp78_;
-	g_hash_table_iter_init (&_tmp76_, value);
-	g_variant_builder_init (&_tmp75_, G_VARIANT_TYPE ("a{ss}"));
-	while (g_hash_table_iter_next (&_tmp76_, &_tmp77_, &_tmp78_)) {
+	GVariantBuilder _tmp48_;
+	GHashTableIter _tmp49_;
+	gpointer _tmp50_;
+	gpointer _tmp51_;
+	g_hash_table_iter_init (&_tmp49_, value);
+	g_variant_builder_init (&_tmp48_, G_VARIANT_TYPE ("a{ss}"));
+	while (g_hash_table_iter_next (&_tmp49_, &_tmp50_, &_tmp51_)) {
 		gchar* _key;
 		gchar* _value;
-		_key = (gchar*) _tmp77_;
-		_value = (gchar*) _tmp78_;
-		g_variant_builder_add (&_tmp75_, "{?*}", g_variant_new_string (_key), g_variant_new_string (_value));
+		_key = (gchar*) _tmp50_;
+		_value = (gchar*) _tmp51_;
+		g_variant_builder_add (&_tmp48_, "{?*}", g_variant_new_string (_key), g_variant_new_string (_value));
 	}
-	return g_variant_ref_sink (g_variant_builder_end (&_tmp75_));
+	return g_variant_ref_sink (g_variant_builder_end (&_tmp48_));
 }
 
 static GHashTable*
 _variant_get10 (GVariant* value)
 {
-	GVariantType* _tmp82_ = NULL;
-	_tmp82_ = g_variant_type_new ("a{ss}");
-	if (value && g_variant_is_of_type (value, _tmp82_)) {
-		GHashTable* _tmp83_;
-		GVariantIter _tmp84_;
-		GVariant* _tmp85_;
-		GVariant* _tmp86_;
-		GHashTable* _tmp87_;
-		_tmp83_ = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
-		g_variant_iter_init (&_tmp84_, value);
-		while (g_variant_iter_loop (&_tmp84_, "{?*}", &_tmp85_, &_tmp86_)) {
-			g_hash_table_insert (_tmp83_, g_variant_dup_string (_tmp85_, NULL), g_variant_dup_string (_tmp86_, NULL));
+	GVariantType* _tmp0_ = NULL;
+	_tmp0_ = g_variant_type_new ("a{ss}");
+	if (value && g_variant_is_of_type (value, _tmp0_)) {
+		GHashTable* _tmp1_;
+		GVariantIter _tmp2_;
+		GVariant* _tmp3_;
+		GVariant* _tmp4_;
+		GHashTable* _tmp5_;
+		_tmp1_ = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
+		g_variant_iter_init (&_tmp2_, value);
+		while (g_variant_iter_loop (&_tmp2_, "{?*}", &_tmp3_, &_tmp4_)) {
+			g_hash_table_insert (_tmp1_, g_variant_dup_string (_tmp3_, NULL), g_variant_dup_string (_tmp4_, NULL));
 		}
-		g_variant_type_free (_tmp82_);
-		_tmp87_ = _tmp83_;
-		return _tmp87_;
+		g_variant_type_free (_tmp0_);
+		_tmp5_ = _tmp1_;
+		return _tmp5_;
 	} else {
-		g_variant_type_free (_tmp82_);
+		g_variant_type_free (_tmp0_);
 		return NULL;
 	}
 }
@@ -442,24 +442,24 @@ _variant_get10 (GVariant* value)
 static GHashTable*
 _variant_get11 (GVariant* value)
 {
-	GVariantType* _tmp92_ = NULL;
-	_tmp92_ = g_variant_type_new ("a{is}");
-	if (value && g_variant_is_of_type (value, _tmp92_)) {
-		GHashTable* _tmp93_;
-		GVariantIter _tmp94_;
-		GVariant* _tmp95_;
-		GVariant* _tmp96_;
-		GHashTable* _tmp97_;
-		_tmp93_ = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free);
-		g_variant_iter_init (&_tmp94_, value);
-		while (g_variant_iter_loop (&_tmp94_, "{?*}", &_tmp95_, &_tmp96_)) {
-			g_hash_table_insert (_tmp93_, (gpointer) ((gintptr) g_variant_get_int32 (_tmp95_)), g_variant_dup_string (_tmp96_, NULL));
+	GVariantType* _tmp0_ = NULL;
+	_tmp0_ = g_variant_type_new ("a{is}");
+	if (value && g_variant_is_of_type (value, _tmp0_)) {
+		GHashTable* _tmp1_;
+		GVariantIter _tmp2_;
+		GVariant* _tmp3_;
+		GVariant* _tmp4_;
+		GHashTable* _tmp5_;
+		_tmp1_ = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free);
+		g_variant_iter_init (&_tmp2_, value);
+		while (g_variant_iter_loop (&_tmp2_, "{?*}", &_tmp3_, &_tmp4_)) {
+			g_hash_table_insert (_tmp1_, (gpointer) ((gintptr) g_variant_get_int32 (_tmp3_)), g_variant_dup_string (_tmp4_, NULL));
 		}
-		g_variant_type_free (_tmp92_);
-		_tmp97_ = _tmp93_;
-		return _tmp97_;
+		g_variant_type_free (_tmp0_);
+		_tmp5_ = _tmp1_;
+		return _tmp5_;
 	} else {
-		g_variant_type_free (_tmp92_);
+		g_variant_type_free (_tmp0_);
 		return NULL;
 	}
 }
@@ -469,30 +469,30 @@ _vala_main (void)
 {
 	GVariant* v = NULL;
 	GVariant* _tmp0_;
-	GVariant* _tmp16_;
-	gchar* _tmp26_;
-	gchar* _tmp27_;
-	gchar* _tmp28_;
-	gchar** _tmp29_;
-	gchar** _tmp30_;
-	gint _tmp30__length1;
-	GVariant* _tmp31_;
+	GVariant* _tmp10_;
+	gchar* _tmp16_;
+	gchar* _tmp17_;
+	gchar* _tmp18_;
+	gchar** _tmp19_;
+	gchar** _tmp20_;
+	gint _tmp20__length1;
+	GVariant* _tmp21_;
 	Foo vsrc = {0};
-	gchar* _tmp40_;
-	Foo _tmp41_ = {0};
-	Foo _tmp42_;
-	GVariant* _tmp44_;
-	GVariant* _tmp45_;
-	const gchar* _tmp46_;
+	gchar* _tmp25_;
+	Foo _tmp26_ = {0};
+	Foo _tmp27_;
+	GVariant* _tmp29_;
+	GVariant* _tmp30_;
+	const gchar* _tmp31_;
 	GHashTable* vsrc2 = NULL;
-	GHashFunc _tmp68_;
-	GEqualFunc _tmp69_;
-	GHashTable* _tmp70_;
-	gchar* _tmp71_;
-	gchar* _tmp72_;
-	gchar* _tmp73_;
-	gchar* _tmp74_;
-	GVariant* _tmp79_;
+	GHashFunc _tmp41_;
+	GEqualFunc _tmp42_;
+	GHashTable* _tmp43_;
+	gchar* _tmp44_;
+	gchar* _tmp45_;
+	gchar* _tmp46_;
+	gchar* _tmp47_;
+	GVariant* _tmp52_;
 	_tmp0_ = g_variant_new_int32 ((gint32) 4711);
 	g_variant_ref_sink (_tmp0_);
 	_g_variant_unref0 (v);
@@ -509,175 +509,175 @@ _vala_main (void)
 	}
 	{
 		gint16* i16 = NULL;
-		GVariant* _tmp5_;
-		gint16* _tmp6_;
-		_tmp5_ = v;
-		_tmp6_ = _variant_get2 (_tmp5_);
-		i16 = _tmp6_;
+		GVariant* _tmp3_;
+		gint16* _tmp4_;
+		_tmp3_ = v;
+		_tmp4_ = _variant_get2 (_tmp3_);
+		i16 = _tmp4_;
 		_vala_assert (i16 == NULL, "i16 == null");
 		_g_free0 (i16);
 	}
 	{
 		gint32* i32 = NULL;
-		GVariant* _tmp9_;
-		gint32* _tmp10_;
-		gint32 _tmp13_;
-		_tmp9_ = v;
-		_tmp10_ = _variant_get3 (_tmp9_);
-		i32 = _tmp10_;
-		_tmp13_ = (gint32) 4711;
-		_vala_assert (_int32_equal (i32, &_tmp13_) == TRUE, "i32 == 4711");
+		GVariant* _tmp5_;
+		gint32* _tmp6_;
+		gint32 _tmp7_;
+		_tmp5_ = v;
+		_tmp6_ = _variant_get3 (_tmp5_);
+		i32 = _tmp6_;
+		_tmp7_ = (gint32) 4711;
+		_vala_assert (_int32_equal (i32, &_tmp7_) == TRUE, "i32 == 4711");
 		_g_free0 (i32);
 	}
 	{
 		gchar* s = NULL;
-		GVariant* _tmp14_;
-		gchar* _tmp15_;
-		_tmp14_ = v;
-		_tmp15_ = _variant_get4 (_tmp14_);
-		s = _tmp15_;
+		GVariant* _tmp8_;
+		gchar* _tmp9_;
+		_tmp8_ = v;
+		_tmp9_ = _variant_get4 (_tmp8_);
+		s = _tmp9_;
 		_vala_assert (s == NULL, "s == null");
 		_g_free0 (s);
 	}
-	_tmp16_ = g_variant_new_boolean (TRUE);
-	g_variant_ref_sink (_tmp16_);
+	_tmp10_ = g_variant_new_boolean (TRUE);
+	g_variant_ref_sink (_tmp10_);
 	_g_variant_unref0 (v);
-	v = _tmp16_;
+	v = _tmp10_;
 	{
 		gboolean* b = NULL;
-		GVariant* _tmp17_;
-		gboolean* _tmp18_;
-		gboolean _tmp21_;
-		_tmp17_ = v;
-		_tmp18_ = _variant_get5 (_tmp17_);
-		b = _tmp18_;
-		_tmp21_ = TRUE;
-		_vala_assert (_bool_equal (b, &_tmp21_) == TRUE, "b == true");
+		GVariant* _tmp11_;
+		gboolean* _tmp12_;
+		gboolean _tmp13_;
+		_tmp11_ = v;
+		_tmp12_ = _variant_get5 (_tmp11_);
+		b = _tmp12_;
+		_tmp13_ = TRUE;
+		_vala_assert (_bool_equal (b, &_tmp13_) == TRUE, "b == true");
 		_g_free0 (b);
 	}
 	{
 		gint32* i32 = NULL;
-		GVariant* _tmp22_;
-		gint32* _tmp23_;
-		_tmp22_ = v;
-		_tmp23_ = _variant_get6 (_tmp22_);
-		i32 = _tmp23_;
+		GVariant* _tmp14_;
+		gint32* _tmp15_;
+		_tmp14_ = v;
+		_tmp15_ = _variant_get6 (_tmp14_);
+		i32 = _tmp15_;
 		_vala_assert (i32 == NULL, "i32 == null");
 		_g_free0 (i32);
 	}
-	_tmp26_ = g_strdup ("foo");
-	_tmp27_ = g_strdup ("bar");
-	_tmp28_ = g_strdup ("manam");
-	_tmp29_ = g_new0 (gchar*, 3 + 1);
-	_tmp29_[0] = _tmp26_;
-	_tmp29_[1] = _tmp27_;
-	_tmp29_[2] = _tmp28_;
-	_tmp30_ = _tmp29_;
-	_tmp30__length1 = 3;
-	_tmp31_ = g_variant_new_strv (_tmp30_, 3);
-	g_variant_ref_sink (_tmp31_);
+	_tmp16_ = g_strdup ("foo");
+	_tmp17_ = g_strdup ("bar");
+	_tmp18_ = g_strdup ("manam");
+	_tmp19_ = g_new0 (gchar*, 3 + 1);
+	_tmp19_[0] = _tmp16_;
+	_tmp19_[1] = _tmp17_;
+	_tmp19_[2] = _tmp18_;
+	_tmp20_ = _tmp19_;
+	_tmp20__length1 = 3;
+	_tmp21_ = g_variant_new_strv (_tmp20_, 3);
+	g_variant_ref_sink (_tmp21_);
 	_g_variant_unref0 (v);
-	v = _tmp31_;
-	_tmp30_ = (_vala_array_free (_tmp30_, _tmp30__length1, (GDestroyNotify) g_free), NULL);
+	v = _tmp21_;
+	_tmp20_ = (_vala_array_free (_tmp20_, _tmp20__length1, (GDestroyNotify) g_free), NULL);
 	{
 		gchar** sa = NULL;
-		GVariant* _tmp32_;
-		gchar** _tmp33_ = NULL;
-		gint _tmp33__length1 = 0;
+		GVariant* _tmp22_;
+		gchar** _tmp23_ = NULL;
+		gint _tmp23__length1 = 0;
 		gint sa_length1;
 		gint _sa_size_;
-		const gchar* _tmp39_;
-		_tmp32_ = v;
-		_tmp33_ = _variant_get7 (_tmp32_, &_tmp33__length1);
-		sa = _tmp33_;
-		sa_length1 = _tmp33__length1;
+		const gchar* _tmp24_;
+		_tmp22_ = v;
+		_tmp23_ = _variant_get7 (_tmp22_, &_tmp23__length1);
+		sa = _tmp23_;
+		sa_length1 = _tmp23__length1;
 		_sa_size_ = sa_length1;
 		_vala_assert (sa != NULL, "sa != null");
-		_tmp39_ = sa[2];
-		_vala_assert (g_strcmp0 (_tmp39_, "manam") == 0, "sa[2] == \"manam\"");
+		_tmp24_ = sa[2];
+		_vala_assert (g_strcmp0 (_tmp24_, "manam") == 0, "sa[2] == \"manam\"");
 		sa = (_vala_array_free (sa, sa_length1, (GDestroyNotify) g_free), NULL);
 	}
-	_tmp40_ = g_strdup ("foo");
-	_g_free0 (_tmp41_.s);
-	_tmp41_.s = _tmp40_;
-	_tmp41_.u64 = G_MAXUINT64;
-	_tmp41_.b = TRUE;
-	vsrc = _tmp41_;
-	_tmp42_ = vsrc;
-	_tmp44_ = _variant_new1 (_tmp42_);
+	_tmp25_ = g_strdup ("foo");
+	_g_free0 (_tmp26_.s);
+	_tmp26_.s = _tmp25_;
+	_tmp26_.u64 = G_MAXUINT64;
+	_tmp26_.b = TRUE;
+	vsrc = _tmp26_;
+	_tmp27_ = vsrc;
+	_tmp29_ = _variant_new1 (_tmp27_);
 	_g_variant_unref0 (v);
-	v = _tmp44_;
-	_tmp45_ = v;
-	_tmp46_ = g_variant_get_type_string (_tmp45_);
-	_vala_assert (g_strcmp0 ("(stb)", _tmp46_) == 0, "\"(stb)\" == v.get_type_string ()");
+	v = _tmp29_;
+	_tmp30_ = v;
+	_tmp31_ = g_variant_get_type_string (_tmp30_);
+	_vala_assert (g_strcmp0 ("(stb)", _tmp31_) == 0, "\"(stb)\" == v.get_type_string ()");
 	{
 		Foo real_st = {0};
-		GVariant* _tmp47_;
-		Foo _tmp48_;
-		Foo _tmp54_;
-		const gchar* _tmp55_;
-		Foo _tmp56_;
-		Foo _tmp57_;
+		GVariant* _tmp32_;
+		Foo _tmp33_;
+		Foo _tmp34_;
+		const gchar* _tmp35_;
+		Foo _tmp36_;
+		Foo _tmp37_;
 		Foo* st = NULL;
-		GVariant* _tmp58_;
-		Foo* _tmp59_;
-		const gchar* _tmp67_;
-		_tmp47_ = v;
-		_variant_get8 (_tmp47_, &_tmp48_);
-		real_st = _tmp48_;
-		_tmp54_ = real_st;
-		_tmp55_ = _tmp54_.s;
-		_vala_assert (g_strcmp0 (_tmp55_, "foo") == 0, "real_st.s == \"foo\"");
-		_tmp56_ = real_st;
-		_vala_assert (_tmp56_.u64 == G_MAXUINT64, "real_st.u64 == uint64.MAX");
-		_tmp57_ = real_st;
-		_vala_assert (_tmp57_.b == TRUE, "real_st.b == true");
-		_tmp58_ = v;
-		_tmp59_ = _variant_get9 (_tmp58_);
-		st = _tmp59_;
+		GVariant* _tmp38_;
+		Foo* _tmp39_;
+		const gchar* _tmp40_;
+		_tmp32_ = v;
+		_variant_get8 (_tmp32_, &_tmp33_);
+		real_st = _tmp33_;
+		_tmp34_ = real_st;
+		_tmp35_ = _tmp34_.s;
+		_vala_assert (g_strcmp0 (_tmp35_, "foo") == 0, "real_st.s == \"foo\"");
+		_tmp36_ = real_st;
+		_vala_assert (_tmp36_.u64 == G_MAXUINT64, "real_st.u64 == uint64.MAX");
+		_tmp37_ = real_st;
+		_vala_assert (_tmp37_.b == TRUE, "real_st.b == true");
+		_tmp38_ = v;
+		_tmp39_ = _variant_get9 (_tmp38_);
+		st = _tmp39_;
 		_vala_assert (st != NULL, "st != null");
-		_tmp67_ = (*st).s;
-		_vala_assert (g_strcmp0 (_tmp67_, "foo") == 0, "st.s == \"foo\"");
+		_tmp40_ = (*st).s;
+		_vala_assert (g_strcmp0 (_tmp40_, "foo") == 0, "st.s == \"foo\"");
 		_vala_assert ((*st).u64 == G_MAXUINT64, "st.u64 == uint64.MAX");
 		_vala_assert ((*st).b == TRUE, "st.b == true");
 		_foo_free0 (st);
 		foo_destroy (&real_st);
 	}
-	_tmp68_ = g_str_hash;
-	_tmp69_ = g_str_equal;
-	_tmp70_ = g_hash_table_new_full (_tmp68_, _tmp69_, _g_free0_, _g_free0_);
-	vsrc2 = _tmp70_;
-	_tmp71_ = g_strdup ("foo");
-	_tmp72_ = g_strdup ("bar");
-	g_hash_table_insert (vsrc2, _tmp71_, _tmp72_);
-	_tmp73_ = g_strdup ("bar");
-	_tmp74_ = g_strdup ("manam");
-	g_hash_table_insert (vsrc2, _tmp73_, _tmp74_);
-	_tmp79_ = _variant_new2 (vsrc2);
+	_tmp41_ = g_str_hash;
+	_tmp42_ = g_str_equal;
+	_tmp43_ = g_hash_table_new_full (_tmp41_, _tmp42_, _g_free0_, _g_free0_);
+	vsrc2 = _tmp43_;
+	_tmp44_ = g_strdup ("foo");
+	_tmp45_ = g_strdup ("bar");
+	g_hash_table_insert (vsrc2, _tmp44_, _tmp45_);
+	_tmp46_ = g_strdup ("bar");
+	_tmp47_ = g_strdup ("manam");
+	g_hash_table_insert (vsrc2, _tmp46_, _tmp47_);
+	_tmp52_ = _variant_new2 (vsrc2);
 	_g_variant_unref0 (v);
-	v = _tmp79_;
+	v = _tmp52_;
 	{
 		GHashTable* dict = NULL;
-		GVariant* _tmp80_;
-		GHashTable* _tmp81_;
-		gconstpointer _tmp88_;
-		gconstpointer _tmp89_;
-		_tmp80_ = v;
-		_tmp81_ = _variant_get10 (_tmp80_);
-		dict = _tmp81_;
-		_tmp88_ = g_hash_table_lookup (dict, "foo");
-		_vala_assert (g_strcmp0 ((const gchar*) _tmp88_, "bar") == 0, "dict.lookup (\"foo\") == \"bar\"");
-		_tmp89_ = g_hash_table_lookup (dict, "bar");
-		_vala_assert (g_strcmp0 ((const gchar*) _tmp89_, "manam") == 0, "dict.lookup (\"bar\") == \"manam\"");
+		GVariant* _tmp53_;
+		GHashTable* _tmp54_;
+		gconstpointer _tmp55_;
+		gconstpointer _tmp56_;
+		_tmp53_ = v;
+		_tmp54_ = _variant_get10 (_tmp53_);
+		dict = _tmp54_;
+		_tmp55_ = g_hash_table_lookup (dict, "foo");
+		_vala_assert (g_strcmp0 ((const gchar*) _tmp55_, "bar") == 0, "dict.lookup (\"foo\") == \"bar\"");
+		_tmp56_ = g_hash_table_lookup (dict, "bar");
+		_vala_assert (g_strcmp0 ((const gchar*) _tmp56_, "manam") == 0, "dict.lookup (\"bar\") == \"manam\"");
 		_g_hash_table_unref0 (dict);
 	}
 	{
 		GHashTable* dict = NULL;
-		GVariant* _tmp90_;
-		GHashTable* _tmp91_;
-		_tmp90_ = v;
-		_tmp91_ = _variant_get11 (_tmp90_);
-		dict = _tmp91_;
+		GVariant* _tmp57_;
+		GHashTable* _tmp58_;
+		_tmp57_ = v;
+		_tmp58_ = _variant_get11 (_tmp57_);
+		dict = _tmp58_;
 		_vala_assert (dict == NULL, "dict == null");
 		_g_hash_table_unref0 (dict);
 	}
diff --git a/tests/basic-types/gvariants.c-expected b/tests/basic-types/gvariants.c-expected
index dc037ded2..c12ca233b 100644
--- a/tests/basic-types/gvariants.c-expected
+++ b/tests/basic-types/gvariants.c-expected
@@ -139,28 +139,28 @@ static gchar**
 _variant_get2 (GVariant* value,
                gint* result_length1)
 {
-	gchar** _tmp10_;
-	gint _tmp10__length;
-	gint _tmp10__size;
-	gint _tmp10__length1;
-	GVariantIter _tmp11_;
-	GVariant* _tmp12_;
-	_tmp10_ = g_new (gchar*, 5);
-	_tmp10__length = 0;
-	_tmp10__size = 4;
-	_tmp10__length1 = 0;
-	g_variant_iter_init (&_tmp11_, value);
-	for (; (_tmp12_ = g_variant_iter_next_value (&_tmp11_)) != NULL; _tmp10__length1++) {
-		if (_tmp10__size == _tmp10__length) {
-			_tmp10__size = 2 * _tmp10__size;
-			_tmp10_ = g_renew (gchar*, _tmp10_, _tmp10__size + 1);
+	gchar** _tmp0_;
+	gint _tmp0__length;
+	gint _tmp0__size;
+	gint _tmp0__length1;
+	GVariantIter _tmp1_;
+	GVariant* _tmp2_;
+	_tmp0_ = g_new (gchar*, 5);
+	_tmp0__length = 0;
+	_tmp0__size = 4;
+	_tmp0__length1 = 0;
+	g_variant_iter_init (&_tmp1_, value);
+	for (; (_tmp2_ = g_variant_iter_next_value (&_tmp1_)) != NULL; _tmp0__length1++) {
+		if (_tmp0__size == _tmp0__length) {
+			_tmp0__size = 2 * _tmp0__size;
+			_tmp0_ = g_renew (gchar*, _tmp0_, _tmp0__size + 1);
 		}
-		_tmp10_[_tmp10__length++] = g_variant_dup_string (_tmp12_, NULL);
-		g_variant_unref (_tmp12_);
+		_tmp0_[_tmp0__length++] = g_variant_dup_string (_tmp2_, NULL);
+		g_variant_unref (_tmp2_);
 	}
-	*result_length1 = _tmp10__length1;
-	_tmp10_[_tmp10__length] = NULL;
-	return _tmp10_;
+	*result_length1 = _tmp0__length1;
+	_tmp0_[_tmp0__length] = NULL;
+	return _tmp0_;
 }
 
 void
@@ -179,7 +179,7 @@ string_array_conversion (void)
 	gint _tmp9__length1 = 0;
 	gint sa_length1;
 	gint _sa_size_;
-	const gchar* _tmp13_;
+	const gchar* _tmp10_;
 	_tmp0_ = g_strdup ("foo");
 	_tmp1_ = g_strdup ("bar");
 	_tmp2_ = g_new0 (gchar*, 2 + 1);
@@ -196,8 +196,8 @@ string_array_conversion (void)
 	sa_length1 = _tmp9__length1;
 	_sa_size_ = sa_length1;
 	_vala_assert (sa_length1 == 2, "sa.length == 2");
-	_tmp13_ = sa[1];
-	_vala_assert (g_strcmp0 (_tmp13_, "bar") == 0, "sa[1] == \"bar\"");
+	_tmp10_ = sa[1];
+	_vala_assert (g_strcmp0 (_tmp10_, "bar") == 0, "sa[1] == \"bar\"");
 	sa = (_vala_array_free (sa, sa_length1, (GDestroyNotify) g_free), NULL);
 	_g_variant_unref0 (v);
 }
@@ -230,37 +230,37 @@ _variant_get3 (GVariant* value,
                gint* result_length1,
                gint* result_length2)
 {
-	gchar** _tmp14_;
-	gint _tmp14__length;
-	gint _tmp14__size;
-	gint _tmp14__length1;
-	GVariantIter _tmp15_;
-	GVariant* _tmp16_;
-	_tmp14_ = g_new (gchar*, 5);
-	_tmp14__length = 0;
-	_tmp14__size = 4;
-	_tmp14__length1 = 0;
-	g_variant_iter_init (&_tmp15_, value);
-	for (; (_tmp16_ = g_variant_iter_next_value (&_tmp15_)) != NULL; _tmp14__length1++) {
-		gint _tmp14__length2;
-		GVariantIter _tmp17_;
-		GVariant* _tmp18_;
-		_tmp14__length2 = 0;
-		g_variant_iter_init (&_tmp17_, _tmp16_);
-		for (; (_tmp18_ = g_variant_iter_next_value (&_tmp17_)) != NULL; _tmp14__length2++) {
-			if (_tmp14__size == _tmp14__length) {
-				_tmp14__size = 2 * _tmp14__size;
-				_tmp14_ = g_renew (gchar*, _tmp14_, _tmp14__size + 1);
+	gchar** _tmp0_;
+	gint _tmp0__length;
+	gint _tmp0__size;
+	gint _tmp0__length1;
+	GVariantIter _tmp1_;
+	GVariant* _tmp2_;
+	_tmp0_ = g_new (gchar*, 5);
+	_tmp0__length = 0;
+	_tmp0__size = 4;
+	_tmp0__length1 = 0;
+	g_variant_iter_init (&_tmp1_, value);
+	for (; (_tmp2_ = g_variant_iter_next_value (&_tmp1_)) != NULL; _tmp0__length1++) {
+		gint _tmp0__length2;
+		GVariantIter _tmp3_;
+		GVariant* _tmp4_;
+		_tmp0__length2 = 0;
+		g_variant_iter_init (&_tmp3_, _tmp2_);
+		for (; (_tmp4_ = g_variant_iter_next_value (&_tmp3_)) != NULL; _tmp0__length2++) {
+			if (_tmp0__size == _tmp0__length) {
+				_tmp0__size = 2 * _tmp0__size;
+				_tmp0_ = g_renew (gchar*, _tmp0_, _tmp0__size + 1);
 			}
-			_tmp14_[_tmp14__length++] = g_variant_dup_string (_tmp18_, NULL);
-			g_variant_unref (_tmp18_);
+			_tmp0_[_tmp0__length++] = g_variant_dup_string (_tmp4_, NULL);
+			g_variant_unref (_tmp4_);
 		}
-		*result_length2 = _tmp14__length2;
-		g_variant_unref (_tmp16_);
+		*result_length2 = _tmp0__length2;
+		g_variant_unref (_tmp2_);
 	}
-	*result_length1 = _tmp14__length1;
-	_tmp14_[_tmp14__length] = NULL;
-	return _tmp14_;
+	*result_length1 = _tmp0__length1;
+	_tmp0_[_tmp0__length] = NULL;
+	return _tmp0_;
 }
 
 void
@@ -283,9 +283,9 @@ string_array_2d_conversion (void)
 	gint _tmp13__length2 = 0;
 	gint sa_length1;
 	gint sa_length2;
-	gint _tmp19_;
-	gint _tmp20_;
-	const gchar* _tmp21_;
+	gint _tmp14_;
+	gint _tmp15_;
+	const gchar* _tmp16_;
 	_tmp0_ = g_strdup ("foo");
 	_tmp1_ = g_strdup ("faz");
 	_tmp2_ = g_strdup ("bar");
@@ -306,12 +306,12 @@ string_array_2d_conversion (void)
 	sa = _tmp13_;
 	sa_length1 = _tmp13__length1;
 	sa_length2 = _tmp13__length2;
-	_tmp19_ = sa_length1;
-	_vala_assert (_tmp19_ == 2, "sa.length[0] == 2");
-	_tmp20_ = sa_length2;
-	_vala_assert (_tmp20_ == 2, "sa.length[1] == 2");
-	_tmp21_ = sa[(1 * sa_length2) + 1];
-	_vala_assert (g_strcmp0 (_tmp21_, "baz") == 0, "sa[1,1] == \"baz\"");
+	_tmp14_ = sa_length1;
+	_vala_assert (_tmp14_ == 2, "sa.length[0] == 2");
+	_tmp15_ = sa_length2;
+	_vala_assert (_tmp15_ == 2, "sa.length[1] == 2");
+	_tmp16_ = sa[(1 * sa_length2) + 1];
+	_vala_assert (g_strcmp0 (_tmp16_, "baz") == 0, "sa[1,1] == \"baz\"");
 	sa = (_vala_array_free (sa, sa_length1 * sa_length2, (GDestroyNotify) g_free), NULL);
 	_g_variant_unref0 (v);
 }
@@ -352,46 +352,46 @@ _variant_get4 (GVariant* value,
                gint* result_length2,
                gint* result_length3)
 {
-	gchar** _tmp20_;
-	gint _tmp20__length;
-	gint _tmp20__size;
-	gint _tmp20__length1;
-	GVariantIter _tmp21_;
-	GVariant* _tmp22_;
-	_tmp20_ = g_new (gchar*, 5);
-	_tmp20__length = 0;
-	_tmp20__size = 4;
-	_tmp20__length1 = 0;
-	g_variant_iter_init (&_tmp21_, value);
-	for (; (_tmp22_ = g_variant_iter_next_value (&_tmp21_)) != NULL; _tmp20__length1++) {
-		gint _tmp20__length2;
-		GVariantIter _tmp23_;
-		GVariant* _tmp24_;
-		_tmp20__length2 = 0;
-		g_variant_iter_init (&_tmp23_, _tmp22_);
-		for (; (_tmp24_ = g_variant_iter_next_value (&_tmp23_)) != NULL; _tmp20__length2++) {
-			gint _tmp20__length3;
-			GVariantIter _tmp25_;
-			GVariant* _tmp26_;
-			_tmp20__length3 = 0;
-			g_variant_iter_init (&_tmp25_, _tmp24_);
-			for (; (_tmp26_ = g_variant_iter_next_value (&_tmp25_)) != NULL; _tmp20__length3++) {
-				if (_tmp20__size == _tmp20__length) {
-					_tmp20__size = 2 * _tmp20__size;
-					_tmp20_ = g_renew (gchar*, _tmp20_, _tmp20__size + 1);
+	gchar** _tmp0_;
+	gint _tmp0__length;
+	gint _tmp0__size;
+	gint _tmp0__length1;
+	GVariantIter _tmp1_;
+	GVariant* _tmp2_;
+	_tmp0_ = g_new (gchar*, 5);
+	_tmp0__length = 0;
+	_tmp0__size = 4;
+	_tmp0__length1 = 0;
+	g_variant_iter_init (&_tmp1_, value);
+	for (; (_tmp2_ = g_variant_iter_next_value (&_tmp1_)) != NULL; _tmp0__length1++) {
+		gint _tmp0__length2;
+		GVariantIter _tmp3_;
+		GVariant* _tmp4_;
+		_tmp0__length2 = 0;
+		g_variant_iter_init (&_tmp3_, _tmp2_);
+		for (; (_tmp4_ = g_variant_iter_next_value (&_tmp3_)) != NULL; _tmp0__length2++) {
+			gint _tmp0__length3;
+			GVariantIter _tmp5_;
+			GVariant* _tmp6_;
+			_tmp0__length3 = 0;
+			g_variant_iter_init (&_tmp5_, _tmp4_);
+			for (; (_tmp6_ = g_variant_iter_next_value (&_tmp5_)) != NULL; _tmp0__length3++) {
+				if (_tmp0__size == _tmp0__length) {
+					_tmp0__size = 2 * _tmp0__size;
+					_tmp0_ = g_renew (gchar*, _tmp0_, _tmp0__size + 1);
 				}
-				_tmp20_[_tmp20__length++] = g_variant_dup_string (_tmp26_, NULL);
-				g_variant_unref (_tmp26_);
+				_tmp0_[_tmp0__length++] = g_variant_dup_string (_tmp6_, NULL);
+				g_variant_unref (_tmp6_);
 			}
-			*result_length3 = _tmp20__length3;
-			g_variant_unref (_tmp24_);
+			*result_length3 = _tmp0__length3;
+			g_variant_unref (_tmp4_);
 		}
-		*result_length2 = _tmp20__length2;
-		g_variant_unref (_tmp22_);
+		*result_length2 = _tmp0__length2;
+		g_variant_unref (_tmp2_);
 	}
-	*result_length1 = _tmp20__length1;
-	_tmp20_[_tmp20__length] = NULL;
-	return _tmp20_;
+	*result_length1 = _tmp0__length1;
+	_tmp0_[_tmp0__length] = NULL;
+	return _tmp0_;
 }
 
 void
@@ -421,13 +421,13 @@ string_array_3d_conversion (void)
 	gint sa_length1;
 	gint sa_length2;
 	gint sa_length3;
-	gint _tmp27_;
-	gint _tmp28_;
-	gint _tmp29_;
-	const gchar* _tmp30_;
-	const gchar* _tmp31_;
-	const gchar* _tmp32_;
-	const gchar* _tmp33_;
+	gint _tmp20_;
+	gint _tmp21_;
+	gint _tmp22_;
+	const gchar* _tmp23_;
+	const gchar* _tmp24_;
+	const gchar* _tmp25_;
+	const gchar* _tmp26_;
 	_tmp0_ = g_strdup ("foo");
 	_tmp1_ = g_strdup ("bar");
 	_tmp2_ = g_strdup ("baz");
@@ -458,20 +458,20 @@ string_array_3d_conversion (void)
 	sa_length1 = _tmp19__length1;
 	sa_length2 = _tmp19__length2;
 	sa_length3 = _tmp19__length3;
-	_tmp27_ = sa_length1;
-	_vala_assert (_tmp27_ == 2, "sa.length[0] == 2");
-	_tmp28_ = sa_length2;
-	_vala_assert (_tmp28_ == 2, "sa.length[1] == 2");
-	_tmp29_ = sa_length3;
-	_vala_assert (_tmp29_ == 2, "sa.length[2] == 2");
-	_tmp30_ = sa[(((0 * sa_length2) + 1) * sa_length3) + 0];
-	_vala_assert (g_strcmp0 (_tmp30_, "baz") == 0, "sa[0,1,0] == \"baz\"");
-	_tmp31_ = sa[(((0 * sa_length2) + 1) * sa_length3) + 1];
-	_vala_assert (g_strcmp0 (_tmp31_, "man") == 0, "sa[0,1,1] == \"man\"");
-	_tmp32_ = sa[(((1 * sa_length2) + 1) * sa_length3) + 0];
-	_vala_assert (g_strcmp0 (_tmp32_, "baz2") == 0, "sa[1,1,0] == \"baz2\"");
-	_tmp33_ = sa[(((1 * sa_length2) + 1) * sa_length3) + 1];
-	_vala_assert (g_strcmp0 (_tmp33_, "man2") == 0, "sa[1,1,1] == \"man2\"");
+	_tmp20_ = sa_length1;
+	_vala_assert (_tmp20_ == 2, "sa.length[0] == 2");
+	_tmp21_ = sa_length2;
+	_vala_assert (_tmp21_ == 2, "sa.length[1] == 2");
+	_tmp22_ = sa_length3;
+	_vala_assert (_tmp22_ == 2, "sa.length[2] == 2");
+	_tmp23_ = sa[(((0 * sa_length2) + 1) * sa_length3) + 0];
+	_vala_assert (g_strcmp0 (_tmp23_, "baz") == 0, "sa[0,1,0] == \"baz\"");
+	_tmp24_ = sa[(((0 * sa_length2) + 1) * sa_length3) + 1];
+	_vala_assert (g_strcmp0 (_tmp24_, "man") == 0, "sa[0,1,1] == \"man\"");
+	_tmp25_ = sa[(((1 * sa_length2) + 1) * sa_length3) + 0];
+	_vala_assert (g_strcmp0 (_tmp25_, "baz2") == 0, "sa[1,1,0] == \"baz2\"");
+	_tmp26_ = sa[(((1 * sa_length2) + 1) * sa_length3) + 1];
+	_vala_assert (g_strcmp0 (_tmp26_, "man2") == 0, "sa[1,1,1] == \"man2\"");
 	sa = (_vala_array_free (sa, (sa_length1 * sa_length2) * sa_length3, (GDestroyNotify) g_free), NULL);
 	_g_variant_unref0 (v);
 }
@@ -523,27 +523,27 @@ static gdouble*
 _variant_get6 (GVariant* value,
                gint* result_length1)
 {
-	gdouble* _tmp8_;
-	gint _tmp8__length;
-	gint _tmp8__size;
-	gint _tmp8__length1;
-	GVariantIter _tmp9_;
-	GVariant* _tmp10_;
-	_tmp8_ = g_new (gdouble, 5);
-	_tmp8__length = 0;
-	_tmp8__size = 4;
-	_tmp8__length1 = 0;
-	g_variant_iter_init (&_tmp9_, value);
-	for (; (_tmp10_ = g_variant_iter_next_value (&_tmp9_)) != NULL; _tmp8__length1++) {
-		if (_tmp8__size == _tmp8__length) {
-			_tmp8__size = 2 * _tmp8__size;
-			_tmp8_ = g_renew (gdouble, _tmp8_, _tmp8__size + 1);
+	gdouble* _tmp0_;
+	gint _tmp0__length;
+	gint _tmp0__size;
+	gint _tmp0__length1;
+	GVariantIter _tmp1_;
+	GVariant* _tmp2_;
+	_tmp0_ = g_new (gdouble, 5);
+	_tmp0__length = 0;
+	_tmp0__size = 4;
+	_tmp0__length1 = 0;
+	g_variant_iter_init (&_tmp1_, value);
+	for (; (_tmp2_ = g_variant_iter_next_value (&_tmp1_)) != NULL; _tmp0__length1++) {
+		if (_tmp0__size == _tmp0__length) {
+			_tmp0__size = 2 * _tmp0__size;
+			_tmp0_ = g_renew (gdouble, _tmp0_, _tmp0__size + 1);
 		}
-		_tmp8_[_tmp8__length++] = g_variant_get_double (_tmp10_);
-		g_variant_unref (_tmp10_);
+		_tmp0_[_tmp0__length++] = g_variant_get_double (_tmp2_);
+		g_variant_unref (_tmp2_);
 	}
-	*result_length1 = _tmp8__length1;
-	return _tmp8_;
+	*result_length1 = _tmp0__length1;
+	return _tmp0_;
 }
 
 void
@@ -560,7 +560,7 @@ double_array_conversion (void)
 	gint _tmp7__length1 = 0;
 	gint da_length1;
 	gint _da_size_;
-	gdouble _tmp11_;
+	gdouble _tmp8_;
 	_tmp0_ = g_new0 (gdouble, 2);
 	_tmp0_[0] = 42.23;
 	_tmp0_[1] = 47.11;
@@ -575,8 +575,8 @@ double_array_conversion (void)
 	da_length1 = _tmp7__length1;
 	_da_size_ = da_length1;
 	_vala_assert (da_length1 == 2, "da.length == 2");
-	_tmp11_ = da[1];
-	_vala_assert (_tmp11_ == 47.11, "da[1] == 47.11");
+	_tmp8_ = da[1];
+	_vala_assert (_tmp8_ == 47.11, "da[1] == 47.11");
 	da = (g_free (da), NULL);
 	_g_variant_unref0 (v);
 }
@@ -609,36 +609,36 @@ _variant_get7 (GVariant* value,
                gint* result_length1,
                gint* result_length2)
 {
-	gdouble* _tmp10_;
-	gint _tmp10__length;
-	gint _tmp10__size;
-	gint _tmp10__length1;
-	GVariantIter _tmp11_;
-	GVariant* _tmp12_;
-	_tmp10_ = g_new (gdouble, 5);
-	_tmp10__length = 0;
-	_tmp10__size = 4;
-	_tmp10__length1 = 0;
-	g_variant_iter_init (&_tmp11_, value);
-	for (; (_tmp12_ = g_variant_iter_next_value (&_tmp11_)) != NULL; _tmp10__length1++) {
-		gint _tmp10__length2;
-		GVariantIter _tmp13_;
-		GVariant* _tmp14_;
-		_tmp10__length2 = 0;
-		g_variant_iter_init (&_tmp13_, _tmp12_);
-		for (; (_tmp14_ = g_variant_iter_next_value (&_tmp13_)) != NULL; _tmp10__length2++) {
-			if (_tmp10__size == _tmp10__length) {
-				_tmp10__size = 2 * _tmp10__size;
-				_tmp10_ = g_renew (gdouble, _tmp10_, _tmp10__size + 1);
+	gdouble* _tmp0_;
+	gint _tmp0__length;
+	gint _tmp0__size;
+	gint _tmp0__length1;
+	GVariantIter _tmp1_;
+	GVariant* _tmp2_;
+	_tmp0_ = g_new (gdouble, 5);
+	_tmp0__length = 0;
+	_tmp0__size = 4;
+	_tmp0__length1 = 0;
+	g_variant_iter_init (&_tmp1_, value);
+	for (; (_tmp2_ = g_variant_iter_next_value (&_tmp1_)) != NULL; _tmp0__length1++) {
+		gint _tmp0__length2;
+		GVariantIter _tmp3_;
+		GVariant* _tmp4_;
+		_tmp0__length2 = 0;
+		g_variant_iter_init (&_tmp3_, _tmp2_);
+		for (; (_tmp4_ = g_variant_iter_next_value (&_tmp3_)) != NULL; _tmp0__length2++) {
+			if (_tmp0__size == _tmp0__length) {
+				_tmp0__size = 2 * _tmp0__size;
+				_tmp0_ = g_renew (gdouble, _tmp0_, _tmp0__size + 1);
 			}
-			_tmp10_[_tmp10__length++] = g_variant_get_double (_tmp14_);
-			g_variant_unref (_tmp14_);
+			_tmp0_[_tmp0__length++] = g_variant_get_double (_tmp4_);
+			g_variant_unref (_tmp4_);
 		}
-		*result_length2 = _tmp10__length2;
-		g_variant_unref (_tmp12_);
+		*result_length2 = _tmp0__length2;
+		g_variant_unref (_tmp2_);
 	}
-	*result_length1 = _tmp10__length1;
-	return _tmp10_;
+	*result_length1 = _tmp0__length1;
+	return _tmp0_;
 }
 
 void
@@ -657,9 +657,9 @@ double_array_2d_conversion (void)
 	gint _tmp9__length2 = 0;
 	gint da_length1;
 	gint da_length2;
-	gint _tmp15_;
-	gint _tmp16_;
-	gdouble _tmp17_;
+	gint _tmp10_;
+	gint _tmp11_;
+	gdouble _tmp12_;
 	_tmp0_ = g_new0 (gdouble, 2 * 2);
 	_tmp0_[0] = 42.23;
 	_tmp0_[1] = 11.47;
@@ -676,12 +676,12 @@ double_array_2d_conversion (void)
 	da = _tmp9_;
 	da_length1 = _tmp9__length1;
 	da_length2 = _tmp9__length2;
-	_tmp15_ = da_length1;
-	_vala_assert (_tmp15_ == 2, "da.length[0] == 2");
-	_tmp16_ = da_length2;
-	_vala_assert (_tmp16_ == 2, "da.length[1] == 2");
-	_tmp17_ = da[(1 * da_length2) + 1];
-	_vala_assert (_tmp17_ == 23.42, "da[1,1] == 23.42");
+	_tmp10_ = da_length1;
+	_vala_assert (_tmp10_ == 2, "da.length[0] == 2");
+	_tmp11_ = da_length2;
+	_vala_assert (_tmp11_ == 2, "da.length[1] == 2");
+	_tmp12_ = da[(1 * da_length2) + 1];
+	_vala_assert (_tmp12_ == 23.42, "da[1,1] == 23.42");
 	da = (g_free (da), NULL);
 	_g_variant_unref0 (v);
 }
@@ -757,22 +757,22 @@ static void
 _variant_get8 (GVariant* value,
                Foo * result)
 {
-	Foo _tmp6_;
-	GVariantIter _tmp7_;
-	GVariant* _tmp8_;
-	GVariant* _tmp9_;
-	GVariant* _tmp10_;
-	g_variant_iter_init (&_tmp7_, value);
-	_tmp8_ = g_variant_iter_next_value (&_tmp7_);
-	_tmp6_.s = g_variant_dup_string (_tmp8_, NULL);
-	g_variant_unref (_tmp8_);
-	_tmp9_ = g_variant_iter_next_value (&_tmp7_);
-	_tmp6_.u64 = g_variant_get_uint64 (_tmp9_);
-	g_variant_unref (_tmp9_);
-	_tmp10_ = g_variant_iter_next_value (&_tmp7_);
-	_tmp6_.b = g_variant_get_boolean (_tmp10_);
-	g_variant_unref (_tmp10_);
-	*result = _tmp6_;
+	Foo _tmp0_;
+	GVariantIter _tmp1_;
+	GVariant* _tmp2_;
+	GVariant* _tmp3_;
+	GVariant* _tmp4_;
+	g_variant_iter_init (&_tmp1_, value);
+	_tmp2_ = g_variant_iter_next_value (&_tmp1_);
+	_tmp0_.s = g_variant_dup_string (_tmp2_, NULL);
+	g_variant_unref (_tmp2_);
+	_tmp3_ = g_variant_iter_next_value (&_tmp1_);
+	_tmp0_.u64 = g_variant_get_uint64 (_tmp3_);
+	g_variant_unref (_tmp3_);
+	_tmp4_ = g_variant_iter_next_value (&_tmp1_);
+	_tmp0_.b = g_variant_get_boolean (_tmp4_);
+	g_variant_unref (_tmp4_);
+	*result = _tmp0_;
 }
 
 void
@@ -786,10 +786,10 @@ struct_conversion (void)
 	GVariant* _tmp4_;
 	Foo st = {0};
 	Foo _tmp5_;
-	Foo _tmp11_;
-	const gchar* _tmp12_;
-	Foo _tmp13_;
-	Foo _tmp14_;
+	Foo _tmp6_;
+	const gchar* _tmp7_;
+	Foo _tmp8_;
+	Foo _tmp9_;
 	_tmp0_ = g_strdup ("foo");
 	_g_free0 (_tmp1_.s);
 	_tmp1_.s = _tmp0_;
@@ -801,13 +801,13 @@ struct_conversion (void)
 	v = _tmp4_;
 	_variant_get8 (v, &_tmp5_);
 	st = _tmp5_;
-	_tmp11_ = st;
-	_tmp12_ = _tmp11_.s;
-	_vala_assert (g_strcmp0 (_tmp12_, "foo") == 0, "st.s == \"foo\"");
-	_tmp13_ = st;
-	_vala_assert (_tmp13_.u64 == G_MAXUINT64, "st.u64 == uint64.MAX");
-	_tmp14_ = st;
-	_vala_assert (_tmp14_.b == TRUE, "st.b == true");
+	_tmp6_ = st;
+	_tmp7_ = _tmp6_.s;
+	_vala_assert (g_strcmp0 (_tmp7_, "foo") == 0, "st.s == \"foo\"");
+	_tmp8_ = st;
+	_vala_assert (_tmp8_.u64 == G_MAXUINT64, "st.u64 == uint64.MAX");
+	_tmp9_ = st;
+	_vala_assert (_tmp9_.b == TRUE, "st.b == true");
 	foo_destroy (&st);
 	_g_variant_unref0 (v);
 	foo_destroy (&s);
diff --git a/tests/dbus/bug602003_client.c-expected b/tests/dbus/bug602003_client.c-expected
index 67aaa5ebb..689bdda84 100644
--- a/tests/dbus/bug602003_client.c-expected
+++ b/tests/dbus/bug602003_client.c-expected
@@ -326,28 +326,28 @@ static gchar**
 _variant_get1 (GVariant* value,
                gint* result_length1)
 {
-	gchar** _tmp5_;
-	gint _tmp5__length;
-	gint _tmp5__size;
-	gint _tmp5__length1;
-	GVariantIter _tmp6_;
-	GVariant* _tmp7_;
-	_tmp5_ = g_new (gchar*, 5);
-	_tmp5__length = 0;
-	_tmp5__size = 4;
-	_tmp5__length1 = 0;
-	g_variant_iter_init (&_tmp6_, value);
-	for (; (_tmp7_ = g_variant_iter_next_value (&_tmp6_)) != NULL; _tmp5__length1++) {
-		if (_tmp5__size == _tmp5__length) {
-			_tmp5__size = 2 * _tmp5__size;
-			_tmp5_ = g_renew (gchar*, _tmp5_, _tmp5__size + 1);
+	gchar** _tmp0_;
+	gint _tmp0__length;
+	gint _tmp0__size;
+	gint _tmp0__length1;
+	GVariantIter _tmp1_;
+	GVariant* _tmp2_;
+	_tmp0_ = g_new (gchar*, 5);
+	_tmp0__length = 0;
+	_tmp0__size = 4;
+	_tmp0__length1 = 0;
+	g_variant_iter_init (&_tmp1_, value);
+	for (; (_tmp2_ = g_variant_iter_next_value (&_tmp1_)) != NULL; _tmp0__length1++) {
+		if (_tmp0__size == _tmp0__length) {
+			_tmp0__size = 2 * _tmp0__size;
+			_tmp0_ = g_renew (gchar*, _tmp0_, _tmp0__size + 1);
 		}
-		_tmp5_[_tmp5__length++] = g_variant_dup_string (_tmp7_, NULL);
-		g_variant_unref (_tmp7_);
+		_tmp0_[_tmp0__length++] = g_variant_dup_string (_tmp2_, NULL);
+		g_variant_unref (_tmp2_);
 	}
-	*result_length1 = _tmp5__length1;
-	_tmp5_[_tmp5__length] = NULL;
-	return _tmp5_;
+	*result_length1 = _tmp0__length1;
+	_tmp0_[_tmp0__length] = NULL;
+	return _tmp0_;
 }
 
 static void
@@ -364,9 +364,9 @@ _vala_main (void)
 	gint _tmp4__length1 = 0;
 	gint s_length1;
 	gint _s_size_;
-	gboolean _tmp8_ = FALSE;
-	gchar** _tmp9_;
-	gint _tmp9__length1;
+	gboolean _tmp5_ = FALSE;
+	gchar** _tmp6_;
+	gint _tmp6__length1;
 	GError* _inner_error0_ = NULL;
 	_tmp0_ = (Test*) g_initable_new (TYPE_TEST_PROXY, NULL, &_inner_error0_, "g-flags", 0, "g-name", "org.example.Test", "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", "/org/example/test", "g-interface-name", "org.example.Test", NULL);
 	test = (Test*) _tmp0_;
@@ -389,20 +389,20 @@ _vala_main (void)
 	s = _tmp4_;
 	s_length1 = _tmp4__length1;
 	_s_size_ = s_length1;
-	_tmp9_ = s;
-	_tmp9__length1 = s_length1;
-	if (_tmp9__length1 == 1) {
-		gchar** _tmp10_;
-		gint _tmp10__length1;
-		const gchar* _tmp11_;
-		_tmp10_ = s;
-		_tmp10__length1 = s_length1;
-		_tmp11_ = _tmp10_[0];
-		_tmp8_ = g_strcmp0 (_tmp11_, "hello") == 0;
+	_tmp6_ = s;
+	_tmp6__length1 = s_length1;
+	if (_tmp6__length1 == 1) {
+		gchar** _tmp7_;
+		gint _tmp7__length1;
+		const gchar* _tmp8_;
+		_tmp7_ = s;
+		_tmp7__length1 = s_length1;
+		_tmp8_ = _tmp7_[0];
+		_tmp5_ = g_strcmp0 (_tmp8_, "hello") == 0;
 	} else {
-		_tmp8_ = FALSE;
+		_tmp5_ = FALSE;
 	}
-	_vala_assert (_tmp8_, "s.length == 1 && s[0] == \"hello\"");
+	_vala_assert (_tmp5_, "s.length == 1 && s[0] == \"hello\"");
 	s = (_vala_array_free (s, s_length1, (GDestroyNotify) g_free), NULL);
 	_g_variant_unref0 (v);
 	_g_object_unref0 (test);
diff --git a/tests/dbus/bug782719_client.c-expected b/tests/dbus/bug782719_client.c-expected
index 1c3c1fe2c..228927c21 100644
--- a/tests/dbus/bug782719_client.c-expected
+++ b/tests/dbus/bug782719_client.c-expected
@@ -383,28 +383,28 @@ static gchar**
 _variant_get1 (GVariant* value,
                gint* result_length1)
 {
-	gchar** _tmp14_;
-	gint _tmp14__length;
-	gint _tmp14__size;
-	gint _tmp14__length1;
-	GVariantIter _tmp15_;
-	GVariant* _tmp16_;
-	_tmp14_ = g_new (gchar*, 5);
-	_tmp14__length = 0;
-	_tmp14__size = 4;
-	_tmp14__length1 = 0;
-	g_variant_iter_init (&_tmp15_, value);
-	for (; (_tmp16_ = g_variant_iter_next_value (&_tmp15_)) != NULL; _tmp14__length1++) {
-		if (_tmp14__size == _tmp14__length) {
-			_tmp14__size = 2 * _tmp14__size;
-			_tmp14_ = g_renew (gchar*, _tmp14_, _tmp14__size + 1);
+	gchar** _tmp0_;
+	gint _tmp0__length;
+	gint _tmp0__size;
+	gint _tmp0__length1;
+	GVariantIter _tmp1_;
+	GVariant* _tmp2_;
+	_tmp0_ = g_new (gchar*, 5);
+	_tmp0__length = 0;
+	_tmp0__size = 4;
+	_tmp0__length1 = 0;
+	g_variant_iter_init (&_tmp1_, value);
+	for (; (_tmp2_ = g_variant_iter_next_value (&_tmp1_)) != NULL; _tmp0__length1++) {
+		if (_tmp0__size == _tmp0__length) {
+			_tmp0__size = 2 * _tmp0__size;
+			_tmp0_ = g_renew (gchar*, _tmp0_, _tmp0__size + 1);
 		}
-		_tmp14_[_tmp14__length++] = g_variant_dup_string (_tmp16_, NULL);
-		g_variant_unref (_tmp16_);
+		_tmp0_[_tmp0__length++] = g_variant_dup_string (_tmp2_, NULL);
+		g_variant_unref (_tmp2_);
 	}
-	*result_length1 = _tmp14__length1;
-	_tmp14_[_tmp14__length] = NULL;
-	return _tmp14_;
+	*result_length1 = _tmp0__length1;
+	_tmp0_[_tmp0__length] = NULL;
+	return _tmp0_;
 }
 
 static void
@@ -432,9 +432,9 @@ _vala_main (void)
 	gint _tmp13__length1 = 0;
 	gint s_length1;
 	gint _s_size_;
-	gboolean _tmp17_ = FALSE;
-	gchar** _tmp18_;
-	gint _tmp18__length1;
+	gboolean _tmp14_ = FALSE;
+	gchar** _tmp15_;
+	gint _tmp15__length1;
 	GError* _inner_error0_ = NULL;
 	_tmp0_ = (Test*) g_initable_new (TYPE_TEST_PROXY, NULL, &_inner_error0_, "g-flags", 0, "g-name", "org.example.Test", "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", "/org/example/test", "g-interface-name", "org.example.Test", NULL);
 	test = (Test*) _tmp0_;
@@ -471,20 +471,20 @@ _vala_main (void)
 	s = _tmp13_;
 	s_length1 = _tmp13__length1;
 	_s_size_ = s_length1;
-	_tmp18_ = s;
-	_tmp18__length1 = s_length1;
-	if (_tmp18__length1 == 1) {
-		gchar** _tmp19_;
-		gint _tmp19__length1;
-		const gchar* _tmp20_;
-		_tmp19_ = s;
-		_tmp19__length1 = s_length1;
-		_tmp20_ = _tmp19_[0];
-		_tmp17_ = g_strcmp0 (_tmp20_, "hello") == 0;
+	_tmp15_ = s;
+	_tmp15__length1 = s_length1;
+	if (_tmp15__length1 == 1) {
+		gchar** _tmp16_;
+		gint _tmp16__length1;
+		const gchar* _tmp17_;
+		_tmp16_ = s;
+		_tmp16__length1 = s_length1;
+		_tmp17_ = _tmp16_[0];
+		_tmp14_ = g_strcmp0 (_tmp17_, "hello") == 0;
 	} else {
-		_tmp17_ = FALSE;
+		_tmp14_ = FALSE;
 	}
-	_vala_assert (_tmp17_, "s.length == 1 && s[0] == \"hello\"");
+	_vala_assert (_tmp14_, "s.length == 1 && s[0] == \"hello\"");
 	s = (_vala_array_free (s, s_length1, (GDestroyNotify) g_free), NULL);
 	_g_variant_unref0 (v);
 	_g_hash_table_unref0 (nested_dict);
diff --git a/tests/dbus/dicts_client.c-expected b/tests/dbus/dicts_client.c-expected
index 6e6aee9ea..f8c01f2bd 100644
--- a/tests/dbus/dicts_client.c-expected
+++ b/tests/dbus/dicts_client.c-expected
@@ -355,28 +355,28 @@ static gchar**
 _variant_get1 (GVariant* value,
                gint* result_length1)
 {
-	gchar** _tmp10_;
-	gint _tmp10__length;
-	gint _tmp10__size;
-	gint _tmp10__length1;
-	GVariantIter _tmp11_;
-	GVariant* _tmp12_;
-	_tmp10_ = g_new (gchar*, 5);
-	_tmp10__length = 0;
-	_tmp10__size = 4;
-	_tmp10__length1 = 0;
-	g_variant_iter_init (&_tmp11_, value);
-	for (; (_tmp12_ = g_variant_iter_next_value (&_tmp11_)) != NULL; _tmp10__length1++) {
-		if (_tmp10__size == _tmp10__length) {
-			_tmp10__size = 2 * _tmp10__size;
-			_tmp10_ = g_renew (gchar*, _tmp10_, _tmp10__size + 1);
+	gchar** _tmp0_;
+	gint _tmp0__length;
+	gint _tmp0__size;
+	gint _tmp0__length1;
+	GVariantIter _tmp1_;
+	GVariant* _tmp2_;
+	_tmp0_ = g_new (gchar*, 5);
+	_tmp0__length = 0;
+	_tmp0__size = 4;
+	_tmp0__length1 = 0;
+	g_variant_iter_init (&_tmp1_, value);
+	for (; (_tmp2_ = g_variant_iter_next_value (&_tmp1_)) != NULL; _tmp0__length1++) {
+		if (_tmp0__size == _tmp0__length) {
+			_tmp0__size = 2 * _tmp0__size;
+			_tmp0_ = g_renew (gchar*, _tmp0_, _tmp0__size + 1);
 		}
-		_tmp10_[_tmp10__length++] = g_variant_dup_string (_tmp12_, NULL);
-		g_variant_unref (_tmp12_);
+		_tmp0_[_tmp0__length++] = g_variant_dup_string (_tmp2_, NULL);
+		g_variant_unref (_tmp2_);
 	}
-	*result_length1 = _tmp10__length1;
-	_tmp10_[_tmp10__length] = NULL;
-	return _tmp10_;
+	*result_length1 = _tmp0__length1;
+	_tmp0_[_tmp0__length] = NULL;
+	return _tmp0_;
 }
 
 static void
@@ -399,9 +399,9 @@ _vala_main (void)
 	gint _tmp9__length1 = 0;
 	gint s_length1;
 	gint _s_size_;
-	gboolean _tmp13_ = FALSE;
-	gchar** _tmp14_;
-	gint _tmp14__length1;
+	gboolean _tmp10_ = FALSE;
+	gchar** _tmp11_;
+	gint _tmp11__length1;
 	GError* _inner_error0_ = NULL;
 	_tmp0_ = (Test*) g_initable_new (TYPE_TEST_PROXY, NULL, &_inner_error0_, "g-flags", 0, "g-name", "org.example.Test", "g-bus-type", G_BUS_TYPE_SESSION, "g-object-path", "/org/example/test", "g-interface-name", "org.example.Test", NULL);
 	test = (Test*) _tmp0_;
@@ -432,20 +432,20 @@ _vala_main (void)
 	s = _tmp9_;
 	s_length1 = _tmp9__length1;
 	_s_size_ = s_length1;
-	_tmp14_ = s;
-	_tmp14__length1 = s_length1;
-	if (_tmp14__length1 == 1) {
-		gchar** _tmp15_;
-		gint _tmp15__length1;
-		const gchar* _tmp16_;
-		_tmp15_ = s;
-		_tmp15__length1 = s_length1;
-		_tmp16_ = _tmp15_[0];
-		_tmp13_ = g_strcmp0 (_tmp16_, "hello") == 0;
+	_tmp11_ = s;
+	_tmp11__length1 = s_length1;
+	if (_tmp11__length1 == 1) {
+		gchar** _tmp12_;
+		gint _tmp12__length1;
+		const gchar* _tmp13_;
+		_tmp12_ = s;
+		_tmp12__length1 = s_length1;
+		_tmp13_ = _tmp12_[0];
+		_tmp10_ = g_strcmp0 (_tmp13_, "hello") == 0;
 	} else {
-		_tmp13_ = FALSE;
+		_tmp10_ = FALSE;
 	}
-	_vala_assert (_tmp13_, "s.length == 1 && s[0] == \"hello\"");
+	_vala_assert (_tmp10_, "s.length == 1 && s[0] == \"hello\"");
 	s = (_vala_array_free (s, s_length1, (GDestroyNotify) g_free), NULL);
 	_g_variant_unref0 (v);
 	_g_hash_table_unref0 (dict);
diff --git a/tests/structs/bug661945.c-expected b/tests/structs/bug661945.c-expected
index f4b3538a2..06becc5d2 100644
--- a/tests/structs/bug661945.c-expected
+++ b/tests/structs/bug661945.c-expected
@@ -85,18 +85,18 @@ static void
 _variant_get1 (GVariant* value,
                Foo * result)
 {
-	Foo _tmp4_;
-	GVariantIter _tmp5_;
-	GVariant* _tmp6_;
-	GVariant* _tmp7_;
-	g_variant_iter_init (&_tmp5_, value);
-	_tmp6_ = g_variant_iter_next_value (&_tmp5_);
-	_tmp4_.a = g_variant_get_int32 (_tmp6_);
-	g_variant_unref (_tmp6_);
-	_tmp7_ = g_variant_iter_next_value (&_tmp5_);
-	_tmp4_.b = g_variant_get_int32 (_tmp7_);
-	g_variant_unref (_tmp7_);
-	*result = _tmp4_;
+	Foo _tmp0_;
+	GVariantIter _tmp1_;
+	GVariant* _tmp2_;
+	GVariant* _tmp3_;
+	g_variant_iter_init (&_tmp1_, value);
+	_tmp2_ = g_variant_iter_next_value (&_tmp1_);
+	_tmp0_.a = g_variant_get_int32 (_tmp2_);
+	g_variant_unref (_tmp2_);
+	_tmp3_ = g_variant_iter_next_value (&_tmp1_);
+	_tmp0_.b = g_variant_get_int32 (_tmp3_);
+	g_variant_unref (_tmp3_);
+	*result = _tmp0_;
 }
 
 static void
@@ -107,8 +107,8 @@ _vala_main (void)
 	GVariant* _tmp2_;
 	Foo b = {0};
 	Foo _tmp3_;
-	Foo _tmp8_;
-	Foo _tmp9_;
+	Foo _tmp4_;
+	Foo _tmp5_;
 	memset (&_tmp0_, 0, sizeof (Foo));
 	_tmp0_.a = 2;
 	_tmp0_.b = 3;
@@ -116,10 +116,10 @@ _vala_main (void)
 	a = _tmp2_;
 	_variant_get1 (a, &_tmp3_);
 	b = _tmp3_;
-	_tmp8_ = b;
-	_vala_assert (_tmp8_.a == 2, "b.a == 2");
-	_tmp9_ = b;
-	_vala_assert (_tmp9_.b == 3, "b.b == 3");
+	_tmp4_ = b;
+	_vala_assert (_tmp4_.a == 2, "b.a == 2");
+	_tmp5_ = b;
+	_vala_assert (_tmp5_.b == 3, "b.b == 3");
 	_g_variant_unref0 (a);
 }