Add Variable class

48 files changed, 542 insertions, 573 deletions

diff --git a/codegen/valaccodearraymodule.vala b/codegen/valaccodearraymodule.vala
index f2ad1ede5..bec474c5b 100644
--- a/codegen/valaccodearraymodule.vala
+++ b/codegen/valaccodearraymodule.vala
@@ -1034,12 +1034,12 @@ public class Vala.CCodeArrayModule : CCodeMethodCallModule {
 	}
 
 	public override void generate_parameter (FormalParameter param, CCodeDeclarationSpace decl_space, Map<int,CCodeFormalParameter> cparam_map, Map<int,CCodeExpression>? carg_map) {
-		if (!(param.parameter_type is ArrayType)) {
+		if (!(param.variable_type is ArrayType)) {
 			base.generate_parameter (param, decl_space, cparam_map, carg_map);
 			return;
 		}
 
-		string ctypename = param.parameter_type.get_cname ();
+		string ctypename = param.variable_type.get_cname ();
 
 		if (param.direction != ParameterDirection.IN) {
 			ctypename += "*";
@@ -1047,7 +1047,7 @@ public class Vala.CCodeArrayModule : CCodeMethodCallModule {
 
 		param.ccodenode = new CCodeFormalParameter (get_variable_cname (param.name), ctypename);
 
-		var array_type = (ArrayType) param.parameter_type;
+		var array_type = (ArrayType) param.variable_type;
 
 		generate_type_declaration (array_type.element_type, decl_space);
 
diff --git a/codegen/valaccodebasemodule.vala b/codegen/valaccodebasemodule.vala
index 677f4ffc8..56e991150 100644
--- a/codegen/valaccodebasemodule.vala
+++ b/codegen/valaccodebasemodule.vala
@@ -345,7 +345,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
 
 			if (context.module_init_method != null) {
 				foreach (FormalParameter parameter in context.module_init_method.get_parameters ()) {
-					if (parameter.parameter_type.data_type == type_module_type) {
+					if (parameter.variable_type.data_type == type_module_type) {
 						in_plugin = true;
 						module_init_param_name = parameter.name;
 						break;
@@ -822,15 +822,15 @@ public class Vala.CCodeBaseModule : CCodeModule {
 			return;
 		}
 
-		generate_type_declaration (f.field_type, decl_space);
+		generate_type_declaration (f.variable_type, decl_space);
 
-		string field_ctype = f.field_type.get_cname ();
+		string field_ctype = f.variable_type.get_cname ();
 		if (f.is_volatile) {
 			field_ctype = "volatile " + field_ctype;
 		}
 
 		var cdecl = new CCodeDeclaration (field_ctype);
-		cdecl.add_declarator (new CCodeVariableDeclarator (f.get_cname (), null, f.field_type.get_cdeclarator_suffix ()));
+		cdecl.add_declarator (new CCodeVariableDeclarator (f.get_cname (), null, f.variable_type.get_cdeclarator_suffix ()));
 		if (f.is_private_symbol ()) {
 			cdecl.modifiers = CCodeModifiers.STATIC;
 		} else {
@@ -855,8 +855,8 @@ public class Vala.CCodeBaseModule : CCodeModule {
 			decl_space.add_type_member_declaration (flock);
 		}
 
-		if (f.field_type is ArrayType && !f.no_array_length) {
-			var array_type = (ArrayType) f.field_type;
+		if (f.variable_type is ArrayType && !f.no_array_length) {
+			var array_type = (ArrayType) f.variable_type;
 
 			if (!array_type.fixed_length) {
 				for (int dim = 1; dim <= array_type.rank; dim++) {
@@ -872,8 +872,8 @@ public class Vala.CCodeBaseModule : CCodeModule {
 					decl_space.add_type_member_declaration (cdecl);
 				}
 			}
-		} else if (f.field_type is DelegateType) {
-			var delegate_type = (DelegateType) f.field_type;
+		} else if (f.variable_type is DelegateType) {
+			var delegate_type = (DelegateType) f.variable_type;
 			if (delegate_type.delegate_symbol.has_target) {
 				// create field to store delegate target
 
@@ -903,7 +903,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
 	public override void visit_field (Field f) {
 		visit_member (f);
 
-		check_type (f.field_type);
+		check_type (f.variable_type);
 
 		f.accept_children (codegen);
 
@@ -912,7 +912,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
 
 		CCodeExpression lhs = null;
 
-		string field_ctype = f.field_type.get_cname ();
+		string field_ctype = f.variable_type.get_cname ();
 		if (f.is_volatile) {
 			field_ctype = "volatile " + field_ctype;
 		}
@@ -929,9 +929,9 @@ public class Vala.CCodeBaseModule : CCodeModule {
 
 				instance_init_fragment.append (new CCodeExpressionStatement (new CCodeAssignment (lhs, rhs)));
 
-				if (f.field_type is ArrayType && !f.no_array_length &&
+				if (f.variable_type is ArrayType && !f.no_array_length &&
 				    f.initializer is ArrayCreationExpression) {
-					var array_type = (ArrayType) f.field_type;
+					var array_type = (ArrayType) f.variable_type;
 					var this_access = new MemberAccess.simple ("this");
 					this_access.value_type = get_data_type_for_symbol ((TypeSymbol) f.parent_symbol);
 					this_access.ccodenode = new CCodeIdentifier ("self");
@@ -965,7 +965,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
 				temp_ref_vars.clear ();
 			}
 			
-			if (requires_destroy (f.field_type) && instance_finalize_fragment != null) {
+			if (requires_destroy (f.variable_type) && instance_finalize_fragment != null) {
 				var this_access = new MemberAccess.simple ("this");
 				this_access.value_type = get_data_type_for_symbol ((TypeSymbol) f.parent_symbol);
 
@@ -978,8 +978,8 @@ public class Vala.CCodeBaseModule : CCodeModule {
 
 				var ma = new MemberAccess (this_access, f.name);
 				ma.symbol_reference = f;
-				ma.value_type = f.field_type.copy ();
-				instance_finalize_fragment.append (new CCodeExpressionStatement (get_unref_expression (lhs, f.field_type, ma)));
+				ma.value_type = f.variable_type.copy ();
+				instance_finalize_fragment.append (new CCodeExpressionStatement (get_unref_expression (lhs, f.variable_type, ma)));
 			}
 		} else if (f.binding == MemberBinding.CLASS)  {
 			if (!is_gtypeinstance) {
@@ -1025,8 +1025,8 @@ public class Vala.CCodeBaseModule : CCodeModule {
 
 			lhs = new CCodeIdentifier (f.get_cname ());
 
-			var var_decl = new CCodeVariableDeclarator (f.get_cname (), null, f.field_type.get_cdeclarator_suffix ());
-			var_decl.initializer = default_value_for_type (f.field_type, true);
+			var var_decl = new CCodeVariableDeclarator (f.get_cname (), null, f.variable_type.get_cdeclarator_suffix ());
+			var_decl.initializer = default_value_for_type (f.variable_type, true);
 
 			if (f.initializer != null) {
 				var init = (CCodeExpression) f.initializer.ccodenode;
@@ -1045,8 +1045,8 @@ public class Vala.CCodeBaseModule : CCodeModule {
 			source_declarations.add_type_member_declaration (var_def);
 
 			/* add array length fields where necessary */
-			if (f.field_type is ArrayType && !f.no_array_length) {
-				var array_type = (ArrayType) f.field_type;
+			if (f.variable_type is ArrayType && !f.no_array_length) {
+				var array_type = (ArrayType) f.variable_type;
 
 				if (!array_type.fixed_length) {
 					for (int dim = 1; dim <= array_type.rank; dim++) {
@@ -1071,8 +1071,8 @@ public class Vala.CCodeBaseModule : CCodeModule {
 						source_declarations.add_type_member_declaration (cdecl);
 					}
 				}
-			} else if (f.field_type is DelegateType) {
-				var delegate_type = (DelegateType) f.field_type;
+			} else if (f.variable_type is DelegateType) {
+				var delegate_type = (DelegateType) f.variable_type;
 				if (delegate_type.delegate_symbol.has_target) {
 					// create field to store delegate target
 
@@ -1107,7 +1107,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
 							var block = new CCodeBlock ();
 							var frag = new CCodeFragment ();
 
-							var temp_decl = get_temp_variable (f.field_type);
+							var temp_decl = get_temp_variable (f.variable_type);
 							var cdecl = new CCodeDeclaration (temp_decl.variable_type.get_cname ());
 							var vardecl = new CCodeVariableDeclarator (temp_decl.name, rhs);
 							cdecl.add_declarator (vardecl);
@@ -1123,9 +1123,9 @@ public class Vala.CCodeBaseModule : CCodeModule {
 							class_init_fragment.append (new CCodeExpressionStatement (new CCodeAssignment (lhs, rhs)));
 						}
 
-						if (f.field_type is ArrayType && !f.no_array_length &&
+						if (f.variable_type is ArrayType && !f.no_array_length &&
 						    f.initializer is ArrayCreationExpression) {
-							var array_type = (ArrayType) f.field_type;
+							var array_type = (ArrayType) f.variable_type;
 							var ma = new MemberAccess.simple (f.name);
 							ma.symbol_reference = f;
 					
@@ -1204,7 +1204,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
 
 	public override void visit_formal_parameter (FormalParameter p) {
 		if (!p.ellipsis) {
-			check_type (p.parameter_type);
+			check_type (p.variable_type);
 		}
 	}
 
@@ -1630,41 +1630,41 @@ public class Vala.CCodeBaseModule : CCodeModule {
 	}
 
 	void capture_parameter (FormalParameter param, CCodeStruct data, CCodeBlock cblock, int block_id, CCodeBlock free_block) {
-		generate_type_declaration (param.parameter_type, source_declarations);
+		generate_type_declaration (param.variable_type, source_declarations);
 
-		var param_type = param.parameter_type.copy ();
+		var param_type = param.variable_type.copy ();
 		param_type.value_owned = true;
 		data.add_field (param_type.get_cname (), get_variable_cname (param.name));
 
-		bool is_unowned_delegate = param.parameter_type is DelegateType && !param.parameter_type.value_owned;
+		bool is_unowned_delegate = param.variable_type is DelegateType && !param.variable_type.value_owned;
 
 		// create copy if necessary as captured variables may need to be kept alive
 		CCodeExpression cparam = get_variable_cexpression (param.name);
-		if (param.parameter_type.is_real_non_null_struct_type ()) {
+		if (param.variable_type.is_real_non_null_struct_type ()) {
 			cparam = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, cparam);
 		}
-		if (requires_copy (param_type) && !param.parameter_type.value_owned && !is_unowned_delegate)  {
+		if (requires_copy (param_type) && !param.variable_type.value_owned && !is_unowned_delegate)  {
 			var ma = new MemberAccess.simple (param.name);
 			ma.symbol_reference = param;
-			ma.value_type = param.parameter_type.copy ();
+			ma.value_type = param.variable_type.copy ();
 			// directly access parameters in ref expressions
 			param.captured = false;
-			cparam = get_ref_cexpression (param.parameter_type, cparam, ma, param);
+			cparam = get_ref_cexpression (param.variable_type, cparam, ma, param);
 			param.captured = true;
 		}
 
 		cblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), get_variable_cname (param.name)), cparam)));
 
-		if (param.parameter_type is ArrayType) {
-			var array_type = (ArrayType) param.parameter_type;
+		if (param.variable_type is ArrayType) {
+			var array_type = (ArrayType) param.variable_type;
 			for (int dim = 1; dim <= array_type.rank; dim++) {
 				data.add_field ("gint", get_array_length_cname (get_variable_cname (param.name), dim));
 				cblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), get_array_length_cname (get_variable_cname (param.name), dim)), new CCodeIdentifier (get_array_length_cname (get_variable_cname (param.name), dim)))));
 			}
-		} else if (param.parameter_type is DelegateType) {
+		} else if (param.variable_type is DelegateType) {
 			data.add_field ("gpointer", get_delegate_target_cname (get_variable_cname (param.name)));
 			cblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), get_delegate_target_cname (get_variable_cname (param.name))), new CCodeIdentifier (get_delegate_target_cname (get_variable_cname (param.name))))));
-			if (param.parameter_type.value_owned) {
+			if (param.variable_type.value_owned) {
 				data.add_field ("GDestroyNotify", get_delegate_target_destroy_notify_cname (get_variable_cname (param.name)));
 				cblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess.pointer (get_variable_cexpression ("_data%d_".printf (block_id)), get_delegate_target_destroy_notify_cname (get_variable_cname (param.name))), new CCodeIdentifier (get_delegate_target_destroy_notify_cname (get_variable_cname (param.name))))));
 			}
@@ -1680,7 +1680,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
 			var ma = new MemberAccess.simple (param.name);
 			ma.symbol_reference = param;
 			ma.value_type = param_type.copy ();
-			free_block.add_statement (new CCodeExpressionStatement (get_unref_expression (new CCodeMemberAccess.pointer (new CCodeIdentifier ("_data%d_".printf (block_id)), get_variable_cname (param.name)), param.parameter_type, ma)));
+			free_block.add_statement (new CCodeExpressionStatement (get_unref_expression (new CCodeMemberAccess.pointer (new CCodeIdentifier ("_data%d_".printf (block_id)), get_variable_cname (param.name)), param.variable_type, ma)));
 
 			if (old_coroutine) {
 				current_method.coroutine = true;
@@ -1900,11 +1900,11 @@ public class Vala.CCodeBaseModule : CCodeModule {
 		if (b.parent_symbol is Method) {
 			var m = (Method) b.parent_symbol;
 			foreach (FormalParameter param in m.get_parameters ()) {
-				if (!param.captured && !param.ellipsis && requires_destroy (param.parameter_type) && param.direction == ParameterDirection.IN) {
+				if (!param.captured && !param.ellipsis && requires_destroy (param.variable_type) && param.direction == ParameterDirection.IN) {
 					var ma = new MemberAccess.simple (param.name);
 					ma.symbol_reference = param;
-					ma.value_type = param.parameter_type.copy ();
-					cblock.add_statement (new CCodeExpressionStatement (get_unref_expression (get_variable_cexpression (param.name), param.parameter_type, ma)));
+					ma.value_type = param.variable_type.copy ();
+					cblock.add_statement (new CCodeExpressionStatement (get_unref_expression (get_variable_cexpression (param.name), param.variable_type, ma)));
 				}
 			}
 		}
@@ -2477,17 +2477,17 @@ public class Vala.CCodeBaseModule : CCodeModule {
 			var s1 = (CCodeExpression) new CCodeMemberAccess.pointer (new CCodeIdentifier ("s1"), f.name); // s1->f
 			var s2 = (CCodeExpression) new CCodeMemberAccess.pointer (new CCodeIdentifier ("s2"), f.name); // s2->f
 
-			var field_type = f.field_type.copy ();
-			make_comparable_cexpression (ref field_type, ref s1, ref field_type, ref s2);
+			var variable_type = f.variable_type.copy ();
+			make_comparable_cexpression (ref variable_type, ref s1, ref variable_type, ref s2);
 
-			if (!(f.field_type is NullType) && f.field_type.compatible (string_type)) {
+			if (!(f.variable_type is NullType) && f.variable_type.compatible (string_type)) {
 				requires_strcmp0 = true;
 				var ccall = new CCodeFunctionCall (new CCodeIdentifier ("_vala_strcmp0"));
 				ccall.add_argument (s1);
 				ccall.add_argument (s2);
 				cexp = ccall;
-			} else if (f.field_type is StructValueType) {
-				var equalfunc = generate_struct_equal_function (f.field_type.data_type as Struct);
+			} else if (f.variable_type is StructValueType) {
+				var equalfunc = generate_struct_equal_function (f.variable_type.data_type as Struct);
 				var ccall = new CCodeFunctionCall (new CCodeIdentifier (equalfunc));
 				ccall.add_argument (s1);
 				ccall.add_argument (s2);
@@ -3256,11 +3256,11 @@ public class Vala.CCodeBaseModule : CCodeModule {
 
 	private void append_param_free (Method m, CCodeFragment cfrag) {
 		foreach (FormalParameter param in m.get_parameters ()) {
-			if (!param.ellipsis && requires_destroy (param.parameter_type) && param.direction == ParameterDirection.IN) {
+			if (!param.ellipsis && requires_destroy (param.variable_type) && param.direction == ParameterDirection.IN) {
 				var ma = new MemberAccess.simple (param.name);
 				ma.symbol_reference = param;
-				ma.value_type = param.parameter_type.copy ();
-				cfrag.append (new CCodeExpressionStatement (get_unref_expression (get_variable_cexpression (param.name), param.parameter_type, ma)));
+				ma.value_type = param.variable_type.copy ();
+				cfrag.append (new CCodeExpressionStatement (get_unref_expression (get_variable_cexpression (param.name), param.variable_type, ma)));
 			}
 		}
 	}
@@ -4204,13 +4204,13 @@ public class Vala.CCodeBaseModule : CCodeModule {
 					param = params_it.get ();
 					ellipsis = param.ellipsis;
 					if (!ellipsis) {
-						if (!param.no_array_length && param.parameter_type is ArrayType) {
-							var array_type = (ArrayType) param.parameter_type;
+						if (!param.no_array_length && param.variable_type is ArrayType) {
+							var array_type = (ArrayType) param.variable_type;
 							for (int dim = 1; dim <= array_type.rank; dim++) {
 								carg_map.set (get_param_pos (param.carray_length_parameter_position + 0.01 * dim), head.get_array_length_cexpression (arg, dim));
 							}
-						} else if (param.parameter_type is DelegateType) {
-							var deleg_type = (DelegateType) param.parameter_type;
+						} else if (param.variable_type is DelegateType) {
+							var deleg_type = (DelegateType) param.variable_type;
 							var d = deleg_type.delegate_symbol;
 							if (d.has_target) {
 								CCodeExpression delegate_target_destroy_notify;
@@ -4247,7 +4247,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
 					break;
 				}
 				
-				if (param.default_expression == null) {
+				if (param.initializer == null) {
 					Report.error (expr.source_reference, "no default expression for argument %d".printf (i));
 					return;
 				}
@@ -4255,9 +4255,9 @@ public class Vala.CCodeBaseModule : CCodeModule {
 				/* evaluate default expression here as the code
 				 * generator might not have visited the formal
 				 * parameter yet */
-				param.default_expression.accept (codegen);
+				param.initializer.accept (codegen);
 			
-				carg_map.set (get_param_pos (param.cparameter_position), (CCodeExpression) param.default_expression.ccodenode);
+				carg_map.set (get_param_pos (param.cparameter_position), (CCodeExpression) param.initializer.ccodenode);
 				i++;
 			}
 
@@ -4355,8 +4355,8 @@ public class Vala.CCodeBaseModule : CCodeModule {
 					}
 					ccomma.append_expression (new CCodeAssignment (lhs, (CCodeExpression) init.initializer.ccodenode));
 
-					if (f.field_type is ArrayType && !f.no_array_length) {
-						var array_type = (ArrayType) f.field_type;
+					if (f.variable_type is ArrayType && !f.no_array_length) {
+						var array_type = (ArrayType) f.variable_type;
 						for (int dim = 1; dim <= array_type.rank; dim++) {
 							if (expr.type_reference.data_type is Struct) {
 								lhs = new CCodeMemberAccess (typed_inst, head.get_array_length_cname (f.get_cname (), dim));
@@ -4366,7 +4366,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
 							var rhs_array_len = head.get_array_length_cexpression (init.initializer, dim);
 							ccomma.append_expression (new CCodeAssignment (lhs, rhs_array_len));
 						}
-					} else if (f.field_type is DelegateType && !f.no_delegate_target) {
+					} else if (f.variable_type is DelegateType && !f.no_delegate_target) {
 						if (expr.type_reference.data_type is Struct) {
 							lhs = new CCodeMemberAccess (typed_inst, get_delegate_target_cname (f.get_cname ()));
 						} else {
@@ -4400,9 +4400,9 @@ public class Vala.CCodeBaseModule : CCodeModule {
 
 	public CCodeExpression? handle_struct_argument (FormalParameter param, Expression arg, CCodeExpression? cexpr) {
 		// pass non-simple struct instances always by reference
-		if (!(arg.value_type is NullType) && param.parameter_type.data_type is Struct && !((Struct) param.parameter_type.data_type).is_simple_type ()) {
+		if (!(arg.value_type is NullType) && param.variable_type.data_type is Struct && !((Struct) param.variable_type.data_type).is_simple_type ()) {
 			// we already use a reference for arguments of ref, out, and nullable parameters
-			if (param.direction == ParameterDirection.IN && !param.parameter_type.nullable) {
+			if (param.direction == ParameterDirection.IN && !param.variable_type.nullable) {
 				var unary = cexpr as CCodeUnaryExpression;
 				if (unary != null && unary.operator == CCodeUnaryOperator.POINTER_INDIRECTION) {
 					// *expr => expr
@@ -4414,7 +4414,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
 					// (tmp = expr, &tmp)
 					var ccomma = new CCodeCommaExpression ();
 
-					var temp_var = get_temp_variable (param.parameter_type, true, null, false);
+					var temp_var = get_temp_variable (param.variable_type, true, null, false);
 					temp_vars.insert (0, temp_var);
 					ccomma.append_expression (new CCodeAssignment (get_variable_cexpression (temp_var.name), cexpr));
 					ccomma.append_expression (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression (temp_var.name)));
@@ -5577,9 +5577,9 @@ public class Vala.CCodeBaseModule : CCodeModule {
 
 	public DataType? get_this_type () {
 		if (current_method != null && current_method.binding == MemberBinding.INSTANCE) {
-			return current_method.this_parameter.parameter_type;
+			return current_method.this_parameter.variable_type;
 		} else if (current_property_accessor != null && current_property_accessor.prop.binding == MemberBinding.INSTANCE) {
-			return current_property_accessor.prop.this_parameter.parameter_type;
+			return current_property_accessor.prop.this_parameter.variable_type;
 		}
 		return null;
 	}
@@ -5603,7 +5603,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
 		var cblock = new CCodeBlock ();
 		foreach (Field f in st.get_fields ()) {
 			if (f.binding == MemberBinding.INSTANCE) {
-				if (requires_destroy (f.field_type)) {
+				if (requires_destroy (f.variable_type)) {
 					var lhs = new CCodeMemberAccess.pointer (new CCodeIdentifier ("self"), f.get_cname ());
 
 					var this_access = new MemberAccess.simple ("this");
@@ -5612,7 +5612,7 @@ public class Vala.CCodeBaseModule : CCodeModule {
 
 					var ma = new MemberAccess (this_access, f.name);
 					ma.symbol_reference = f;
-					cblock.add_statement (new CCodeExpressionStatement (get_unref_expression (lhs, f.field_type, ma)));
+					cblock.add_statement (new CCodeExpressionStatement (get_unref_expression (lhs, f.variable_type, ma)));
 				}
 			}
 		}
@@ -5649,17 +5649,17 @@ public class Vala.CCodeBaseModule : CCodeModule {
 		foreach (Field f in st.get_fields ()) {
 			if (f.binding == MemberBinding.INSTANCE) {
 				CCodeExpression copy = new CCodeMemberAccess.pointer (new CCodeIdentifier ("self"), f.name);
-				if (requires_copy (f.field_type))  {
+				if (requires_copy (f.variable_type))  {
 					var this_access = new MemberAccess.simple ("this");
 					this_access.value_type = get_data_type_for_symbol ((TypeSymbol) f.parent_symbol);
 					this_access.ccodenode = new CCodeIdentifier ("(*self)");
 					var ma = new MemberAccess (this_access, f.name);
 					ma.symbol_reference = f;
-					copy = get_ref_cexpression (f.field_type, copy, ma, f);
+					copy = get_ref_cexpression (f.variable_type, copy, ma, f);
 				}
 				var dest = new CCodeMemberAccess.pointer (new CCodeIdentifier ("dest"), f.name);
 
-				var array_type = f.field_type as ArrayType;
+				var array_type = f.variable_type as ArrayType;
 				if (array_type != null && array_type.fixed_length) {
 					// fixed-length (stack-allocated) arrays
 					source_declarations.add_include ("string.h");
diff --git a/codegen/valaccodedelegatemodule.vala b/codegen/valaccodedelegatemodule.vala
index 3b21bba2b..706d8bfc8 100644
--- a/codegen/valaccodedelegatemodule.vala
+++ b/codegen/valaccodedelegatemodule.vala
@@ -57,8 +57,8 @@ public class Vala.CCodeDelegateModule : CCodeArrayModule {
 			cfundecl.add_parameter ((CCodeFormalParameter) param.ccodenode);
 
 			// handle array parameters
-			if (!param.no_array_length && param.parameter_type is ArrayType) {
-				var array_type = (ArrayType) param.parameter_type;
+			if (!param.no_array_length && param.variable_type is ArrayType) {
+				var array_type = (ArrayType) param.variable_type;
 				
 				var length_ctype = "int";
 				if (param.direction != ParameterDirection.IN) {
@@ -71,8 +71,8 @@ public class Vala.CCodeDelegateModule : CCodeArrayModule {
 				}
 			}
 			// handle delegate parameters
-			if (param.parameter_type is DelegateType) {
-				var deleg_type = (DelegateType) param.parameter_type;
+			if (param.variable_type is DelegateType) {
+				var deleg_type = (DelegateType) param.variable_type;
 				var param_d = deleg_type.delegate_symbol;
 				if (param_d.has_target) {
 					var cparam = new CCodeFormalParameter (get_delegate_target_cname (get_variable_cname (param.name)), "void*");
@@ -398,8 +398,8 @@ public class Vala.CCodeDelegateModule : CCodeArrayModule {
 		var d_params = d.get_parameters ();
 		foreach (FormalParameter param in d_params) {
 			if (dynamic_sig != null
-			    && param.parameter_type is ArrayType
-			    && ((ArrayType) param.parameter_type).element_type.data_type == string_type.data_type) {
+			    && param.variable_type is ArrayType
+			    && ((ArrayType) param.variable_type).element_type.data_type == string_type.data_type) {
 				// use null-terminated string arrays for dynamic signals for compatibility reasons
 				param.no_array_length = true;
 				param.array_null_terminated = true;
@@ -489,8 +489,8 @@ public class Vala.CCodeDelegateModule : CCodeArrayModule {
 			carg_map.set (get_param_pos (param.cparameter_position), arg);
 
 			// handle array arguments
-			if (!param.no_array_length && param.parameter_type is ArrayType) {
-				var array_type = (ArrayType) param.parameter_type;
+			if (!param.no_array_length && param.variable_type is ArrayType) {
+				var array_type = (ArrayType) param.variable_type;
 				for (int dim = 1; dim <= array_type.rank; dim++) {
 					CCodeExpression clength;
 					if (d_params.get (i).array_null_terminated) {
@@ -505,8 +505,8 @@ public class Vala.CCodeDelegateModule : CCodeArrayModule {
 					}
 					carg_map.set (get_param_pos (param.carray_length_parameter_position + 0.01 * dim), clength);
 				}
-			} else if (param.parameter_type is DelegateType) {
-				var deleg_type = (DelegateType) param.parameter_type;
+			} else if (param.variable_type is DelegateType) {
+				var deleg_type = (DelegateType) param.variable_type;
 
 				if (deleg_type.delegate_symbol.has_target) {
 					var ctarget = new CCodeIdentifier (get_delegate_target_cname (d_params.get (i).name));
@@ -613,17 +613,17 @@ public class Vala.CCodeDelegateModule : CCodeArrayModule {
 	}
 
 	public override void generate_parameter (FormalParameter param, CCodeDeclarationSpace decl_space, Map<int,CCodeFormalParameter> cparam_map, Map<int,CCodeExpression>? carg_map) {
-		if (!(param.parameter_type is DelegateType || param.parameter_type is MethodType)) {
+		if (!(param.variable_type is DelegateType || param.variable_type is MethodType)) {
 			base.generate_parameter (param, decl_space, cparam_map, carg_map);
 			return;
 		}
 
-		string ctypename = param.parameter_type.get_cname ();
+		string ctypename = param.variable_type.get_cname ();
 		string target_ctypename = "void*";
 		string target_destroy_notify_ctypename = "GDestroyNotify";
 
 		if (param.parent_symbol is Delegate
-		    && param.parameter_type.get_cname () == ((Delegate) param.parent_symbol).get_cname ()) {
+		    && param.variable_type.get_cname () == ((Delegate) param.parent_symbol).get_cname ()) {
 			// recursive delegate
 			ctypename = "GCallback";
 		}
@@ -641,8 +641,8 @@ public class Vala.CCodeDelegateModule : CCodeArrayModule {
 			carg_map.set (get_param_pos (param.cparameter_position), get_variable_cexpression (param.name));
 		}
 
-		if (param.parameter_type is DelegateType) {
-			var deleg_type = (DelegateType) param.parameter_type;
+		if (param.variable_type is DelegateType) {
+			var deleg_type = (DelegateType) param.variable_type;
 			var d = deleg_type.delegate_symbol;
 
 			generate_delegate_declaration (d, decl_space);
@@ -661,7 +661,7 @@ public class Vala.CCodeDelegateModule : CCodeArrayModule {
 					}
 				}
 			}
-		} else if (param.parameter_type is MethodType) {
+		} else if (param.variable_type is MethodType) {
 			var cparam = new CCodeFormalParameter (get_delegate_target_cname (get_variable_cname (param.name)), target_ctypename);
 			cparam_map.set (get_param_pos (param.cdelegate_target_parameter_position), cparam);
 			if (carg_map != null) {
diff --git a/codegen/valaccodememberaccessmodule.vala b/codegen/valaccodememberaccessmodule.vala
index 57ddcd3f2..52ea34daf 100644
--- a/codegen/valaccodememberaccessmodule.vala
+++ b/codegen/valaccodememberaccessmodule.vala
@@ -395,9 +395,9 @@ public class Vala.CCodeMemberAccessModule : CCodeControlFlowModule {
 					// use closure
 					expr.ccodenode = get_variable_cexpression (p.name);
 				} else {
-					var type_as_struct = p.parameter_type.data_type as Struct;
+					var type_as_struct = p.variable_type.data_type as Struct;
 					if (p.direction != ParameterDirection.IN
-					    || (type_as_struct != null && !type_as_struct.is_simple_type () && !p.parameter_type.nullable)) {
+					    || (type_as_struct != null && !type_as_struct.is_simple_type () && !p.variable_type.nullable)) {
 						expr.ccodenode = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier (get_variable_cname (p.name)));
 					} else {
 						// Property setters of non simple structs shall replace all occurences
diff --git a/codegen/valaccodemethodcallmodule.vala b/codegen/valaccodemethodcallmodule.vala
index 85816eeeb..2f2306bac 100644
--- a/codegen/valaccodemethodcallmodule.vala
+++ b/codegen/valaccodemethodcallmodule.vala
@@ -347,8 +347,8 @@ public class Vala.CCodeMethodCallModule : CCodeAssignmentModule {
 						carg_map = out_arg_map;
 					}
 
-					if (!param.no_array_length && param.parameter_type is ArrayType) {
-						var array_type = (ArrayType) param.parameter_type;
+					if (!param.no_array_length && param.variable_type is ArrayType) {
+						var array_type = (ArrayType) param.variable_type;
 						for (int dim = 1; dim <= array_type.rank; dim++) {
 							CCodeExpression? array_length_expr = null;
 							if (param.array_length_type != null) {
@@ -381,8 +381,8 @@ public class Vala.CCodeMethodCallModule : CCodeAssignmentModule {
 							carg_map.set (get_param_pos (param.carray_length_parameter_position + 0.01 * dim), array_length_expr);
 						}
 						multiple_cargs = true;
-					} else if (param.parameter_type is DelegateType) {
-						var deleg_type = (DelegateType) param.parameter_type;
+					} else if (param.variable_type is DelegateType) {
+						var deleg_type = (DelegateType) param.variable_type;
 						var d = deleg_type.delegate_symbol;
 						if (d.has_target) {
 							CCodeExpression delegate_target_destroy_notify;
@@ -402,14 +402,14 @@ public class Vala.CCodeMethodCallModule : CCodeAssignmentModule {
 								multiple_cargs = true;
 							}
 						}
-					} else if (param.parameter_type is MethodType) {
+					} else if (param.variable_type is MethodType) {
 						// callbacks in dynamic method calls
 						CCodeExpression delegate_target_destroy_notify;
 						carg_map.set (get_param_pos (param.cdelegate_target_parameter_position), get_delegate_target_cexpression (arg, out delegate_target_destroy_notify));
 						multiple_cargs = true;
-					} else if (param.parameter_type is GenericType) {
+					} else if (param.variable_type is GenericType) {
 						if (m != null && m.simple_generics) {
-							var generic_type = (GenericType) param.parameter_type;
+							var generic_type = (GenericType) param.variable_type;
 							int type_param_index = m.get_type_parameter_index (generic_type.type_parameter.name);
 							var type_arg = ma.get_type_arguments ().get (type_param_index);
 							if (requires_copy (type_arg)) {
@@ -445,13 +445,13 @@ public class Vala.CCodeMethodCallModule : CCodeAssignmentModule {
 					// disabled for arrays for now as that requires special handling
 					// (ret_tmp = call (&tmp), var1 = (assign_tmp = dup (tmp), free (var1), assign_tmp), ret_tmp)
 					if (param.direction != ParameterDirection.IN && requires_destroy (arg.value_type)
-					    && (param.direction == ParameterDirection.OUT || !param.parameter_type.value_owned)
-					    && !(param.parameter_type is ArrayType) && !(param.parameter_type is DelegateType)) {
+					    && (param.direction == ParameterDirection.OUT || !param.variable_type.value_owned)
+					    && !(param.variable_type is ArrayType) && !(param.variable_type is DelegateType)) {
 						var unary = (UnaryExpression) arg;
 
 						var ccomma = new CCodeCommaExpression ();
 
-						var temp_var = get_temp_variable (param.parameter_type, param.parameter_type.value_owned);
+						var temp_var = get_temp_variable (param.variable_type, param.variable_type.value_owned);
 						temp_vars.insert (0, temp_var);
 						cexpr = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression (temp_var.name));
 
@@ -478,7 +478,7 @@ public class Vala.CCodeMethodCallModule : CCodeAssignmentModule {
 						var assign_temp_var = get_temp_variable (unary.inner.value_type, unary.inner.value_type.value_owned, null, false);
 						temp_vars.insert (0, assign_temp_var);
 
-						cassign_comma.append_expression (new CCodeAssignment (get_variable_cexpression (assign_temp_var.name), transform_expression (get_variable_cexpression (temp_var.name), param.parameter_type, unary.inner.value_type, arg)));
+						cassign_comma.append_expression (new CCodeAssignment (get_variable_cexpression (assign_temp_var.name), transform_expression (get_variable_cexpression (temp_var.name), param.variable_type, unary.inner.value_type, arg)));
 
 						// unref old value
 						cassign_comma.append_expression (get_unref_expression ((CCodeExpression) unary.inner.ccodenode, arg.value_type, arg));
diff --git a/codegen/valaccodemethodmodule.vala b/codegen/valaccodemethodmodule.vala
index aa786a5eb..a07ac05b9 100644
--- a/codegen/valaccodemethodmodule.vala
+++ b/codegen/valaccodemethodmodule.vala
@@ -544,17 +544,17 @@ public class Vala.CCodeMethodModule : CCodeStructModule {
 					}
 
 					if (param.direction != ParameterDirection.OUT) {
-						var t = param.parameter_type.data_type;
+						var t = param.variable_type.data_type;
 						if (t != null && t.is_reference_type ()) {
-							var type_check = create_method_type_check_statement (m, creturn_type, t, !param.parameter_type.nullable, get_variable_cname (param.name));
+							var type_check = create_method_type_check_statement (m, creturn_type, t, !param.variable_type.nullable, get_variable_cname (param.name));
 							if (type_check != null) {
 								type_check.line = function.line;
 								cinit.append (type_check);
 							}
 						}
 					} else if (!m.coroutine) {
-						var t = param.parameter_type.data_type;
-						if ((t != null && t.is_reference_type ()) || param.parameter_type is ArrayType) {
+						var t = param.variable_type.data_type;
+						if ((t != null && t.is_reference_type ()) || param.variable_type is ArrayType) {
 							// ensure that the passed reference for output parameter is cleared
 							var a = new CCodeAssignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, get_variable_cexpression (param.name)), new CCodeConstant ("NULL"));
 							var cblock = new CCodeBlock ();
@@ -815,19 +815,19 @@ public class Vala.CCodeMethodModule : CCodeStructModule {
 
 	public virtual void generate_parameter (FormalParameter param, CCodeDeclarationSpace decl_space, Map<int,CCodeFormalParameter> cparam_map, Map<int,CCodeExpression>? carg_map) {
 		if (!param.ellipsis) {
-			string ctypename = param.parameter_type.get_cname ();
+			string ctypename = param.variable_type.get_cname ();
 
-			generate_type_declaration (param.parameter_type, decl_space);
+			generate_type_declaration (param.variable_type, decl_space);
 
 			// pass non-simple structs always by reference
-			if (param.parameter_type.data_type is Struct) {
-				var st = (Struct) param.parameter_type.data_type;
+			if (param.variable_type.data_type is Struct) {
+				var st = (Struct) param.variable_type.data_type;
 				if (!st.is_simple_type () && param.direction == ParameterDirection.IN) {
-					if (st.is_immutable && !param.parameter_type.value_owned) {
+					if (st.is_immutable && !param.variable_type.value_owned) {
 						ctypename = "const " + ctypename;
 					}
 
-					if (!param.parameter_type.nullable) {
+					if (!param.variable_type.nullable) {
 						ctypename += "*";
 					}
 				}
diff --git a/codegen/valaccodestructmodule.vala b/codegen/valaccodestructmodule.vala
index 4b3587ab3..16aaf145b 100644
--- a/codegen/valaccodestructmodule.vala
+++ b/codegen/valaccodestructmodule.vala
@@ -66,18 +66,18 @@ public class Vala.CCodeStructModule : CCodeBaseModule {
 		instance_struct.deprecated = st.deprecated;
 
 		foreach (Field f in st.get_fields ()) {
-			string field_ctype = f.field_type.get_cname ();
+			string field_ctype = f.variable_type.get_cname ();
 			if (f.is_volatile) {
 				field_ctype = "volatile " + field_ctype;
 			}
 
 			if (f.binding == MemberBinding.INSTANCE)  {
-				generate_type_declaration (f.field_type, decl_space);
+				generate_type_declaration (f.variable_type, decl_space);
 
-				instance_struct.add_field (field_ctype, f.get_cname () + f.field_type.get_cdeclarator_suffix (), f.deprecated ? " G_GNUC_DEPRECATED" : null);
-				if (f.field_type is ArrayType && !f.no_array_length) {
+				instance_struct.add_field (field_ctype, f.get_cname () + f.variable_type.get_cdeclarator_suffix (), f.deprecated ? " G_GNUC_DEPRECATED" : null);
+				if (f.variable_type is ArrayType && !f.no_array_length) {
 					// create fields to store array dimensions
-					var array_type = (ArrayType) f.field_type;
+					var array_type = (ArrayType) f.variable_type;
 
 					if (!array_type.fixed_length) {
 						var len_type = int_type.copy ();
@@ -90,8 +90,8 @@ public class Vala.CCodeStructModule : CCodeBaseModule {
 							instance_struct.add_field (len_type.get_cname (), head.get_array_size_cname (f.name));
 						}
 					}
-				} else if (f.field_type is DelegateType) {
-					var delegate_type = (DelegateType) f.field_type;
+				} else if (f.variable_type is DelegateType) {
+					var delegate_type = (DelegateType) f.variable_type;
 					if (delegate_type.delegate_symbol.has_target) {
 						// create field to store delegate target
 						instance_struct.add_field ("gpointer", get_delegate_target_cname (f.name));
@@ -259,17 +259,17 @@ public class Vala.CCodeStructModule : CCodeBaseModule {
 		foreach (var f in st.get_fields ()) {
 			if (f.binding == MemberBinding.INSTANCE) {
 				CCodeExpression copy = new CCodeMemberAccess.pointer (new CCodeIdentifier ("self"), f.name);
-				if (requires_copy (f.field_type))  {
+				if (requires_copy (f.variable_type))  {
 					var this_access = new MemberAccess.simple ("this");
 					this_access.value_type = get_data_type_for_symbol ((TypeSymbol) f.parent_symbol);
 					this_access.ccodenode = new CCodeIdentifier ("(*self)");
 					var ma = new MemberAccess (this_access, f.name);
 					ma.symbol_reference = f;
-					copy = get_ref_cexpression (f.field_type, copy, ma, f);
+					copy = get_ref_cexpression (f.variable_type, copy, ma, f);
 				}
 				var dest = new CCodeMemberAccess.pointer (new CCodeIdentifier ("dest"), f.name);
 
-				var array_type = f.field_type as ArrayType;
+				var array_type = f.variable_type as ArrayType;
 				if (array_type != null && array_type.fixed_length) {
 					// fixed-length (stack-allocated) arrays
 					source_declarations.add_include ("string.h");
diff --git a/codegen/valadbusclientmodule.vala b/codegen/valadbusclientmodule.vala
index 9e02444df..cb9ff5d5f 100644
--- a/codegen/valadbusclientmodule.vala
+++ b/codegen/valadbusclientmodule.vala
@@ -173,15 +173,15 @@ public class Vala.DBusClientModule : DBusModule {
 			int i = 0;
 			foreach (FormalParameter param in reply_method.get_parameters ()) {
 				if ((++i) == param_count) {
-					if (!(param.parameter_type is ErrorType)) {
+					if (!(param.variable_type is ErrorType)) {
 						Report.error (null, "DBus reply callbacks must end with GLib.Error argument");
 						return;
 					}
 
 					break;
 				}
-				if (param.parameter_type is ArrayType && ((ArrayType) param.parameter_type).element_type.data_type != string_type.data_type) {
-					var array_type = (ArrayType) param.parameter_type;
+				if (param.variable_type is ArrayType && ((ArrayType) param.variable_type).element_type.data_type != string_type.data_type) {
+					var array_type = (ArrayType) param.variable_type;
 					CCodeDeclaration cdecl;
 					if (dbus_use_ptr_array (array_type)) {
 						cdecl = new CCodeDeclaration ("GPtrArray*");
@@ -195,14 +195,14 @@ public class Vala.DBusClientModule : DBusModule {
 					creply_call.add_argument (new CCodeCastExpression (new CCodeMemberAccess.pointer (new CCodeIdentifier (param.name), dbus_use_ptr_array (array_type) ? "pdata" : "data"), array_type.get_cname ()));
 					creply_call.add_argument (new CCodeMemberAccess.pointer (new CCodeIdentifier (param.name), "len"));
 				} else {
-					var cdecl = new CCodeDeclaration (param.parameter_type.get_cname ());
+					var cdecl = new CCodeDeclaration (param.variable_type.get_cname ());
 					cdecl.add_declarator (new CCodeVariableDeclarator (param.name));
 					cb_fun.block.add_statement (cdecl);
-					cend_call.add_argument (get_dbus_g_type (param.parameter_type));
+					cend_call.add_argument (get_dbus_g_type (param.variable_type));
 					cend_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (param.name)));
 					creply_call.add_argument (new CCodeIdentifier (param.name));
 
-					if (param.parameter_type is ArrayType && ((ArrayType) param.parameter_type).element_type.data_type == string_type.data_type) {
+					if (param.variable_type is ArrayType && ((ArrayType) param.variable_type).element_type.data_type == string_type.data_type) {
 						var cstrvlen = new CCodeFunctionCall (new CCodeIdentifier ("g_strv_length"));
 						cstrvlen.add_argument (new CCodeIdentifier (param.name));
 						creply_call.add_argument (cstrvlen);
@@ -244,8 +244,8 @@ public class Vala.DBusClientModule : DBusModule {
 		}
 
 		foreach (FormalParameter param in method.get_parameters ()) {
-			if (param.parameter_type is MethodType
-			    || param.parameter_type is DelegateType) {
+			if (param.variable_type is MethodType
+			    || param.variable_type is DelegateType) {
 				// callback parameter
 				break;
 			}
@@ -254,7 +254,7 @@ public class Vala.DBusClientModule : DBusModule {
 				continue;
 			}
 
-			var array_type = param.parameter_type as ArrayType;
+			var array_type = param.variable_type as ArrayType;
 			if (array_type != null) {
 				// array parameter
 				if (array_type.element_type.data_type != string_type.data_type) {
@@ -308,9 +308,9 @@ public class Vala.DBusClientModule : DBusModule {
 					ccall.add_argument (new CCodeIdentifier ("G_TYPE_STRV"));
 					ccall.add_argument (new CCodeIdentifier (param.name));
 				}
-			} else if (get_type_signature (param.parameter_type).has_prefix ("(")) {
+			} else if (get_type_signature (param.variable_type).has_prefix ("(")) {
 				// struct parameter
-				var st = (Struct) param.parameter_type.data_type;
+				var st = (Struct) param.variable_type.data_type;
 
 				var array_construct = new CCodeFunctionCall (new CCodeIdentifier ("g_value_array_new"));
 				array_construct.add_argument (new CCodeConstant ("0"));
@@ -338,10 +338,10 @@ public class Vala.DBusClientModule : DBusModule {
 
 					var cinit_call = new CCodeFunctionCall (new CCodeIdentifier ("g_value_init"));
 					cinit_call.add_argument (val_ptr);
-					cinit_call.add_argument (new CCodeIdentifier (f.field_type.data_type.get_type_id ()));
+					cinit_call.add_argument (new CCodeIdentifier (f.variable_type.data_type.get_type_id ()));
 					block.add_statement (new CCodeExpressionStatement (cinit_call));
 
-					var cset_call = new CCodeFunctionCall (new CCodeIdentifier (f.field_type.data_type.get_set_value_function ()));
+					var cset_call = new CCodeFunctionCall (new CCodeIdentifier (f.variable_type.data_type.get_set_value_function ()));
 					cset_call.add_argument (val_ptr);
 					cset_call.add_argument (new CCodeMemberAccess.pointer (new CCodeIdentifier (param.name), f.name));
 					block.add_statement (new CCodeExpressionStatement (cset_call));
@@ -352,10 +352,10 @@ public class Vala.DBusClientModule : DBusModule {
 					block.add_statement (new CCodeExpressionStatement (cappend_call));
 				}
 
-				ccall.add_argument (get_dbus_g_type (param.parameter_type));
+				ccall.add_argument (get_dbus_g_type (param.variable_type));
 				ccall.add_argument (new CCodeIdentifier ("dbus_%s".printf (param.name)));
 			} else {
-				ccall.add_argument (get_dbus_g_type (param.parameter_type));
+				ccall.add_argument (get_dbus_g_type (param.variable_type));
 				ccall.add_argument (new CCodeIdentifier (param.name));
 			}
 		}
@@ -365,7 +365,7 @@ public class Vala.DBusClientModule : DBusModule {
 		var out_marshalling_fragment = new CCodeFragment ();
 
 		foreach (FormalParameter param in method.get_parameters ()) {
-			if (param.parameter_type is MethodType) {
+			if (param.variable_type is MethodType) {
 				// callback parameter
 				break;
 			}
@@ -374,9 +374,9 @@ public class Vala.DBusClientModule : DBusModule {
 				continue;
 			}
 
-			if (get_type_signature (param.parameter_type).has_prefix ("(")) {
+			if (get_type_signature (param.variable_type).has_prefix ("(")) {
 				// struct output parameter
-				var st = (Struct) param.parameter_type.data_type;
+				var st = (Struct) param.variable_type.data_type;
 
 				var cdecl = new CCodeDeclaration ("GValueArray*");
 				cdecl.add_declarator (new CCodeVariableDeclarator ("dbus_%s".printf (param.name)));
@@ -388,13 +388,13 @@ public class Vala.DBusClientModule : DBusModule {
 						continue;
 					}
 
-					var cget_call = new CCodeFunctionCall (new CCodeIdentifier (f.field_type.data_type.get_get_value_function ()));
+					var cget_call = new CCodeFunctionCall (new CCodeIdentifier (f.variable_type.data_type.get_get_value_function ()));
 					cget_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeElementAccess (new CCodeMemberAccess.pointer (new CCodeIdentifier ("dbus_%s".printf (param.name)), "values"), new CCodeConstant (i.to_string ()))));
 
 					var converted_value = cget_call;
 
-					if (requires_copy (f.field_type)) {
-						var dupexpr = get_dup_func_expression (f.field_type, expr.source_reference);
+					if (requires_copy (f.variable_type)) {
+						var dupexpr = get_dup_func_expression (f.variable_type, expr.source_reference);
 						converted_value = new CCodeFunctionCall (dupexpr);
 						converted_value.add_argument (cget_call);
 					}
@@ -405,10 +405,10 @@ public class Vala.DBusClientModule : DBusModule {
 					i++;
 				}
 
-				ccall.add_argument (get_dbus_g_type (param.parameter_type));
+				ccall.add_argument (get_dbus_g_type (param.variable_type));
 				ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier ("dbus_%s".printf (param.name))));
 			} else {
-				ccall.add_argument (get_dbus_g_type (param.parameter_type));
+				ccall.add_argument (get_dbus_g_type (param.variable_type));
 				ccall.add_argument (new CCodeIdentifier (param.name));
 			}
 		}
@@ -470,13 +470,13 @@ public class Vala.DBusClientModule : DBusModule {
 							continue;
 						}
 
-						var cget_call = new CCodeFunctionCall (new CCodeIdentifier (f.field_type.data_type.get_get_value_function ()));
+						var cget_call = new CCodeFunctionCall (new CCodeIdentifier (f.variable_type.data_type.get_get_value_function ()));
 						cget_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeElementAccess (new CCodeMemberAccess.pointer (new CCodeIdentifier ("dbus_result"), "values"), new CCodeConstant (i.to_string ()))));
 
 						var converted_value = cget_call;
 
-						if (requires_copy (f.field_type)) {
-							var dupexpr = get_dup_func_expression (f.field_type, expr.source_reference);
+						if (requires_copy (f.variable_type)) {
+							var dupexpr = get_dup_func_expression (f.variable_type, expr.source_reference);
 							converted_value = new CCodeFunctionCall (dupexpr);
 							converted_value.add_argument (cget_call);
 						}
@@ -594,7 +594,7 @@ public class Vala.DBusClientModule : DBusModule {
 					continue;
 				}
 
-				type_call.add_argument (get_dbus_g_type (f.field_type));
+				type_call.add_argument (get_dbus_g_type (f.variable_type));
 			}
 
 			type_call.add_argument (new CCodeConstant ("G_TYPE_INVALID"));
@@ -877,8 +877,8 @@ public class Vala.DBusClientModule : DBusModule {
 				continue;
 			}
 
-			register_call.add_argument (get_dbus_g_type (param.parameter_type));
-			add_call.add_argument (get_dbus_g_type (param.parameter_type));
+			register_call.add_argument (get_dbus_g_type (param.variable_type));
+			add_call.add_argument (get_dbus_g_type (param.variable_type));
 		}
 		register_call.add_argument (new CCodeIdentifier ("G_TYPE_INVALID"));
 		add_call.add_argument (new CCodeIdentifier ("G_TYPE_INVALID"));
@@ -1540,27 +1540,27 @@ public class Vala.DBusClientModule : DBusModule {
 		string type_signature = "";
 
 		foreach (FormalParameter param in sig.get_parameters ()) {
-			var owned_type = param.parameter_type.copy ();
+			var owned_type = param.variable_type.copy ();
 			owned_type.value_owned = true;
 
 			cdecl = new CCodeDeclaration (owned_type.get_cname ());
-			cdecl.add_declarator (new CCodeVariableDeclarator.zero (param.name, default_value_for_type (param.parameter_type, true)));
+			cdecl.add_declarator (new CCodeVariableDeclarator.zero (param.name, default_value_for_type (param.variable_type, true)));
 			prefragment.append (cdecl);
 
-			if (get_type_signature (param.parameter_type) == null) {
-				Report.error (param.parameter_type.source_reference, "D-Bus serialization of type `%s' is not supported".printf (param.parameter_type.to_string ()));
+			if (get_type_signature (param.variable_type) == null) {
+				Report.error (param.variable_type.source_reference, "D-Bus serialization of type `%s' is not supported".printf (param.variable_type.to_string ()));
 				continue;
 			}
 
-			var st = param.parameter_type.data_type as Struct;
+			var st = param.variable_type.data_type as Struct;
 			if (st != null && !st.is_simple_type ()) {
 				ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (param.name)));
 			} else {
 				ccall.add_argument (new CCodeIdentifier (param.name));
 			}
 
-			if (param.parameter_type is ArrayType) {
-				var array_type = (ArrayType) param.parameter_type;
+			if (param.variable_type is ArrayType) {
+				var array_type = (ArrayType) param.variable_type;
 
 				for (int dim = 1; dim <= array_type.rank; dim++) {
 					string length_cname = get_array_length_cname (param.name, dim);
@@ -1572,10 +1572,10 @@ public class Vala.DBusClientModule : DBusModule {
 				}
 			}
 
-			type_signature += get_type_signature (param.parameter_type);
+			type_signature += get_type_signature (param.variable_type);
 
 			var target = new CCodeIdentifier (param.name);
-			var expr = read_expression (prefragment, param.parameter_type, new CCodeIdentifier ("iter"), target);
+			var expr = read_expression (prefragment, param.variable_type, new CCodeIdentifier ("iter"), target);
 			prefragment.append (new CCodeExpressionStatement (new CCodeAssignment (target, expr)));
 
 			if (requires_destroy (owned_type)) {
@@ -1682,26 +1682,26 @@ public class Vala.DBusClientModule : DBusModule {
 
 		foreach (FormalParameter param in m.get_parameters ()) {
 			if (param.direction == ParameterDirection.IN) {
-				if (param.parameter_type.data_type != null
-				    && param.parameter_type.data_type.get_full_name () == "DBus.BusName") {
+				if (param.variable_type.data_type != null
+				    && param.variable_type.data_type.get_full_name () == "DBus.BusName") {
 					// ignore BusName sender parameters
 					continue;
 				}
 				CCodeExpression expr = new CCodeIdentifier (param.name);
-				if (param.parameter_type.is_real_struct_type ()) {
+				if (param.variable_type.is_real_struct_type ()) {
 					expr = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, expr);
 				}
-				write_expression (prefragment, param.parameter_type, new CCodeIdentifier ("_iter"), expr);
+				write_expression (prefragment, param.variable_type, new CCodeIdentifier ("_iter"), expr);
 			} else {
 				if (no_reply) {
 					Report.error (param.source_reference, "No-reply DBus methods must not have out parameters");
 					break;
 				}
-				cdecl = new CCodeDeclaration (param.parameter_type.get_cname ());
+				cdecl = new CCodeDeclaration (param.variable_type.get_cname ());
 				cdecl.add_declarator (new CCodeVariableDeclarator ("_" + param.name));
 				postfragment.append (cdecl);
 
-				var array_type = param.parameter_type as ArrayType;
+				var array_type = param.variable_type as ArrayType;
 
 				if (array_type != null) {
 					for (int dim = 1; dim <= array_type.rank; dim++) {
@@ -1712,7 +1712,7 @@ public class Vala.DBusClientModule : DBusModule {
 				}
 
 				var target = new CCodeIdentifier ("_" + param.name);
-				var expr = read_expression (postfragment, param.parameter_type, new CCodeIdentifier ("_iter"), target);
+				var expr = read_expression (postfragment, param.variable_type, new CCodeIdentifier ("_iter"), target);
 				postfragment.append (new CCodeExpressionStatement (new CCodeAssignment (target, expr)));
 
 				// TODO check that parameter is not NULL (out parameters are optional)
@@ -2266,7 +2266,7 @@ public class Vala.DBusClientModule : DBusModule {
 
 		foreach (FormalParameter param in m.get_parameters ()) {
 			if (param.direction == ParameterDirection.OUT) {
-				type_signature += get_type_signature (param.parameter_type);
+				type_signature += get_type_signature (param.variable_type);
 			}
 		}
 
diff --git a/codegen/valadbusmodule.vala b/codegen/valadbusmodule.vala
index 1ee94d432..65ce9b03d 100644
--- a/codegen/valadbusmodule.vala
+++ b/codegen/valadbusmodule.vala
@@ -126,7 +126,7 @@ public class Vala.DBusModule : GAsyncModule {
 				str.append_c ('(');
 				foreach (Field f in st.get_fields ()) {
 					if (f.binding == MemberBinding.INSTANCE) {
-						str.append (get_type_signature (f.field_type));
+						str.append (get_type_signature (f.variable_type));
 					}
 				}
 				str.append_c (')');
@@ -418,7 +418,7 @@ public class Vala.DBusModule : GAsyncModule {
 				continue;
 			}
 
-			var field_expr = read_expression (fragment, f.field_type, new CCodeIdentifier (subiter_name), new CCodeMemberAccess (new CCodeIdentifier (temp_name), f.get_cname ()));
+			var field_expr = read_expression (fragment, f.variable_type, new CCodeIdentifier (subiter_name), new CCodeMemberAccess (new CCodeIdentifier (temp_name), f.get_cname ()));
 			fragment.append (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess (new CCodeIdentifier (temp_name), f.get_cname ()), field_expr)));
 		}
 
@@ -783,7 +783,7 @@ public class Vala.DBusModule : GAsyncModule {
 				continue;
 			}
 
-			write_expression (fragment, f.field_type, new CCodeIdentifier (subiter_name), new CCodeMemberAccess (struct_expr, f.get_cname ()));
+			write_expression (fragment, f.variable_type, new CCodeIdentifier (subiter_name), new CCodeMemberAccess (struct_expr, f.get_cname ()));
 		}
 
 		iter_call = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_iter_close_container"));
diff --git a/codegen/valadbusservermodule.vala b/codegen/valadbusservermodule.vala
index 399a1cc4f..54f6474dc 100644
--- a/codegen/valadbusservermodule.vala
+++ b/codegen/valadbusservermodule.vala
@@ -181,11 +181,11 @@ public class Vala.DBusServerModule : DBusClientModule {
 		string type_signature = "";
 
 		foreach (FormalParameter param in m.get_parameters ()) {
-			var owned_type = param.parameter_type.copy ();
+			var owned_type = param.variable_type.copy ();
 			owned_type.value_owned = true;
 
 			cdecl = new CCodeDeclaration (owned_type.get_cname ());
-			cdecl.add_declarator (new CCodeVariableDeclarator.zero (param.name, default_value_for_type (param.parameter_type, true)));
+			cdecl.add_declarator (new CCodeVariableDeclarator.zero (param.name, default_value_for_type (param.variable_type, true)));
 			if (param.direction == ParameterDirection.IN) {
 				in_prefragment.append (cdecl);
 			} else {
@@ -193,8 +193,8 @@ public class Vala.DBusServerModule : DBusClientModule {
 			}
 			if (type_signature == ""
 			    && param.direction == ParameterDirection.IN
-			    && param.parameter_type.data_type != null
-			    && param.parameter_type.data_type.get_full_name () == "DBus.BusName") {
+			    && param.variable_type.data_type != null
+			    && param.variable_type.data_type.get_full_name () == "DBus.BusName") {
 				// first parameter is a string parameter called 'sender'
 				// pass bus name of sender
 				var get_sender = new CCodeFunctionCall (new CCodeIdentifier ("dbus_message_get_sender"));
@@ -203,13 +203,13 @@ public class Vala.DBusServerModule : DBusClientModule {
 				continue;
 			}
 
-			if (get_type_signature (param.parameter_type) == null) {
-				Report.error (param.parameter_type.source_reference, "D-Bus serialization of type `%s' is not supported".printf (param.parameter_type.to_string ()));
+			if (get_type_signature (param.variable_type) == null) {
+				Report.error (param.variable_type.source_reference, "D-Bus serialization of type `%s' is not supported".printf (param.variable_type.to_string ()));
 				continue;
 			}
 
 			if (!m.coroutine || param.direction == ParameterDirection.IN) {
-				var st = param.parameter_type.data_type as Struct;
+				var st = param.variable_type.data_type as Struct;
 				if (param.direction != ParameterDirection.IN
 				    || (st != null && !st.is_simple_type ())) {
 					ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (param.name)));
@@ -220,8 +220,8 @@ public class Vala.DBusServerModule : DBusClientModule {
 				finish_ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (param.name)));
 			}
 
-			if (param.parameter_type is ArrayType) {
-				var array_type = (ArrayType) param.parameter_type;
+			if (param.variable_type is ArrayType) {
+				var array_type = (ArrayType) param.variable_type;
 
 				for (int dim = 1; dim <= array_type.rank; dim++) {
 					string length_cname = get_array_length_cname (param.name, dim);
@@ -244,13 +244,13 @@ public class Vala.DBusServerModule : DBusClientModule {
 			}
 
 			if (param.direction == ParameterDirection.IN) {
-				type_signature += get_type_signature (param.parameter_type);
+				type_signature += get_type_signature (param.variable_type);
 
 				var target = new CCodeIdentifier (param.name);
-				var expr = read_expression (in_prefragment, param.parameter_type, new CCodeIdentifier ("iter"), target);
+				var expr = read_expression (in_prefragment, param.variable_type, new CCodeIdentifier ("iter"), target);
 				in_prefragment.append (new CCodeExpressionStatement (new CCodeAssignment (target, expr)));
 			} else {
-				write_expression (out_postfragment, param.parameter_type, new CCodeIdentifier ("iter"), new CCodeIdentifier (param.name));
+				write_expression (out_postfragment, param.variable_type, new CCodeIdentifier ("iter"), new CCodeIdentifier (param.name));
 			}
 
 			if (requires_destroy (owned_type)) {
@@ -496,8 +496,8 @@ public class Vala.DBusServerModule : DBusClientModule {
 			generate_parameter (param, source_declarations, new HashMap<int,CCodeFormalParameter> (), null);
 
 			function.add_parameter ((CCodeFormalParameter) get_ccodenode (param));
-			if (param.parameter_type is ArrayType) {
-				var array_type = (ArrayType) param.parameter_type;
+			if (param.variable_type is ArrayType) {
+				var array_type = (ArrayType) param.variable_type;
 				for (int dim = 1; dim <= array_type.rank; dim++) {
 					function.add_parameter (new CCodeFormalParameter (head.get_array_length_cname (param.name, dim), "int"));
 				}
@@ -540,10 +540,10 @@ public class Vala.DBusServerModule : DBusClientModule {
 
 		foreach (FormalParameter param in sig.get_parameters ()) {
 			CCodeExpression expr = new CCodeIdentifier (param.name);
-			if (param.parameter_type.is_real_struct_type ()) {
+			if (param.variable_type.is_real_struct_type ()) {
 				expr = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, expr);
 			}
-			write_expression (prefragment, param.parameter_type, new CCodeIdentifier ("_iter"), expr);
+			write_expression (prefragment, param.variable_type, new CCodeIdentifier ("_iter"), expr);
 		}
 
 		var ccall = new CCodeFunctionCall (new CCodeIdentifier ("dbus_connection_send"));
@@ -1295,15 +1295,15 @@ public class Vala.DBusServerModule : DBusClientModule {
 			result += "  <method name=\"%s\">\n".printf (get_dbus_name_for_member (m));
 
 			foreach (var param in m.get_parameters ()) {
-				if (param.parameter_type.data_type != null
-				    && param.parameter_type.data_type.get_full_name () == "DBus.BusName") {
+				if (param.variable_type.data_type != null
+				    && param.variable_type.data_type.get_full_name () == "DBus.BusName") {
 					// skip sender parameter
 					// (implicit in D-Bus)
 					continue;
 				}
 
 				string direction = param.direction == ParameterDirection.IN ? "in" : "out";
-				result += "    <arg name=\"%s\" type=\"%s\" direction=\"%s\"/>\n".printf (param.name, get_type_signature (param.parameter_type), direction);
+				result += "    <arg name=\"%s\" type=\"%s\" direction=\"%s\"/>\n".printf (param.name, get_type_signature (param.variable_type), direction);
 			}
 			if (!(m.return_type is VoidType)) {
 				result += "    <arg name=\"%s\" type=\"%s\" direction=\"out\"/>\n".printf (dbus_result_name (m), get_type_signature (m.return_type));
@@ -1336,7 +1336,7 @@ public class Vala.DBusServerModule : DBusClientModule {
 			result += "  <signal name=\"%s\">\n".printf (get_dbus_name_for_member (sig));
 
 			foreach (var param in sig.get_parameters ()) {
-				result += "    <arg name=\"%s\" type=\"%s\"/>\n".printf (param.name, get_type_signature (param.parameter_type));
+				result += "    <arg name=\"%s\" type=\"%s\"/>\n".printf (param.name, get_type_signature (param.variable_type));
 			}
 
 			result += "  </signal>\n";
diff --git a/codegen/valadovabasemodule.vala b/codegen/valadovabasemodule.vala
index 915448fe9..14d0ee18d 100644
--- a/codegen/valadovabasemodule.vala
+++ b/codegen/valadovabasemodule.vala
@@ -431,9 +431,9 @@ internal class Vala.DovaBaseModule : CCodeModule {
 			return;
 		}
 
-		generate_type_declaration (f.field_type, decl_space);
+		generate_type_declaration (f.variable_type, decl_space);
 
-		string field_ctype = f.field_type.get_cname ();
+		string field_ctype = f.variable_type.get_cname ();
 		if (f.is_volatile) {
 			field_ctype = "volatile " + field_ctype;
 		}
@@ -460,7 +460,7 @@ internal class Vala.DovaBaseModule : CCodeModule {
 
 		CCodeExpression lhs = null;
 
-		string field_ctype = f.field_type.get_cname ();
+		string field_ctype = f.variable_type.get_cname ();
 		if (f.is_volatile) {
 			field_ctype = "volatile " + field_ctype;
 		}
@@ -483,7 +483,7 @@ internal class Vala.DovaBaseModule : CCodeModule {
 				temp_vars.clear ();
 			}
 
-			if (requires_destroy (f.field_type) && instance_finalize_fragment != null) {
+			if (requires_destroy (f.variable_type) && instance_finalize_fragment != null) {
 				var this_access = new MemberAccess.simple ("this");
 				this_access.value_type = get_data_type_for_symbol ((TypeSymbol) f.parent_symbol);
 
@@ -496,7 +496,7 @@ internal class Vala.DovaBaseModule : CCodeModule {
 
 				var ma = new MemberAccess (this_access, f.name);
 				ma.symbol_reference = f;
-				instance_finalize_fragment.append (new CCodeExpressionStatement (get_unref_expression (lhs, f.field_type, ma)));
+				instance_finalize_fragment.append (new CCodeExpressionStatement (get_unref_expression (lhs, f.variable_type, ma)));
 			}
 		} else {
 			generate_field_declaration (f, source_declarations);
@@ -508,7 +508,7 @@ internal class Vala.DovaBaseModule : CCodeModule {
 			lhs = new CCodeIdentifier (f.get_cname ());
 
 			var var_decl = new CCodeVariableDeclarator (f.get_cname ());
-			var_decl.initializer = default_value_for_type (f.field_type, true);
+			var_decl.initializer = default_value_for_type (f.variable_type, true);
 
 			if (f.initializer != null) {
 				var rhs = (CCodeExpression) f.initializer.ccodenode;
@@ -673,21 +673,21 @@ internal class Vala.DovaBaseModule : CCodeModule {
 	}
 
 	void capture_parameter (FormalParameter param, CCodeStruct data, CCodeBlock cblock, int block_id, CCodeBlock free_block) {
-		generate_type_declaration (param.parameter_type, source_declarations);
+		generate_type_declaration (param.variable_type, source_declarations);
 
-		var param_type = param.parameter_type.copy ();
+		var param_type = param.variable_type.copy ();
 		param_type.value_owned = true;
 		data.add_field (param_type.get_cname (), get_variable_cname (param.name));
 
 		// create copy if necessary as captured variables may need to be kept alive
 		CCodeExpression cparam = get_variable_cexpression (param.name);
-		if (requires_copy (param_type) && !param.parameter_type.value_owned)  {
+		if (requires_copy (param_type) && !param.variable_type.value_owned)  {
 			var ma = new MemberAccess.simple (param.name);
 			ma.symbol_reference = param;
-			ma.value_type = param.parameter_type.copy ();
+			ma.value_type = param.variable_type.copy ();
 			// directly access parameters in ref expressions
 			param.captured = false;
-			cparam = get_ref_cexpression (param.parameter_type, cparam, ma, param);
+			cparam = get_ref_cexpression (param.variable_type, cparam, ma, param);
 			param.captured = true;
 		}
 
@@ -697,7 +697,7 @@ internal class Vala.DovaBaseModule : CCodeModule {
 			var ma = new MemberAccess.simple (param.name);
 			ma.symbol_reference = param;
 			ma.value_type = param_type.copy ();
-			free_block.add_statement (new CCodeExpressionStatement (get_unref_expression (new CCodeMemberAccess.pointer (new CCodeIdentifier ("_data%d_".printf (block_id)), get_variable_cname (param.name)), param.parameter_type, ma)));
+			free_block.add_statement (new CCodeExpressionStatement (get_unref_expression (new CCodeMemberAccess.pointer (new CCodeIdentifier ("_data%d_".printf (block_id)), get_variable_cname (param.name)), param.variable_type, ma)));
 		}
 	}
 
@@ -893,10 +893,10 @@ internal class Vala.DovaBaseModule : CCodeModule {
 		if (b.parent_symbol is Method) {
 			var m = (Method) b.parent_symbol;
 			foreach (FormalParameter param in m.get_parameters ()) {
-				if (!param.captured && requires_destroy (param.parameter_type) && param.direction == ParameterDirection.IN) {
+				if (!param.captured && requires_destroy (param.variable_type) && param.direction == ParameterDirection.IN) {
 					var ma = new MemberAccess.simple (param.name);
 					ma.symbol_reference = param;
-					cblock.add_statement (new CCodeExpressionStatement (get_unref_expression (get_variable_cexpression (param.name), param.parameter_type, ma)));
+					cblock.add_statement (new CCodeExpressionStatement (get_unref_expression (get_variable_cexpression (param.name), param.variable_type, ma)));
 				}
 			}
 		}
@@ -1447,10 +1447,10 @@ internal class Vala.DovaBaseModule : CCodeModule {
 
 	private void append_param_free (Method m, CCodeFragment cfrag) {
 		foreach (FormalParameter param in m.get_parameters ()) {
-			if (requires_destroy (param.parameter_type) && param.direction == ParameterDirection.IN) {
+			if (requires_destroy (param.variable_type) && param.direction == ParameterDirection.IN) {
 				var ma = new MemberAccess.simple (param.name);
 				ma.symbol_reference = param;
-				cfrag.append (new CCodeExpressionStatement (get_unref_expression (get_variable_cexpression (param.name), param.parameter_type, ma)));
+				cfrag.append (new CCodeExpressionStatement (get_unref_expression (get_variable_cexpression (param.name), param.variable_type, ma)));
 			}
 		}
 	}
@@ -1827,7 +1827,7 @@ internal class Vala.DovaBaseModule : CCodeModule {
 					break;
 				}
 
-				if (param.default_expression == null) {
+				if (param.initializer == null) {
 					Report.error (expr.source_reference, "no default expression for argument %d".printf (i));
 					return;
 				}
@@ -1835,9 +1835,9 @@ internal class Vala.DovaBaseModule : CCodeModule {
 				/* evaluate default expression here as the code
 				 * generator might not have visited the formal
 				 * parameter yet */
-				param.default_expression.accept (codegen);
+				param.initializer.accept (codegen);
 
-				creation_call.add_argument ((CCodeExpression) param.default_expression.ccodenode);
+				creation_call.add_argument ((CCodeExpression) param.initializer.ccodenode);
 				i++;
 			}
 
@@ -2278,11 +2278,11 @@ internal class Vala.DovaBaseModule : CCodeModule {
 			foreach (FormalParameter param in d.get_parameters ()) {
 				method_param_iter.next ();
 				var method_param = method_param_iter.get ();
-				string ctype = param.parameter_type.get_cname ();
-				if (param.parameter_type is GenericType && !(method_param.parameter_type is GenericType)) {
-					ctype = method_param.parameter_type.get_cname () + "*";
+				string ctype = param.variable_type.get_cname ();
+				if (param.variable_type is GenericType && !(method_param.variable_type is GenericType)) {
+					ctype = method_param.variable_type.get_cname () + "*";
 					call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier (param.name)));
-				} else if (!(param.parameter_type is GenericType) && method_param.parameter_type is GenericType) {
+				} else if (!(param.variable_type is GenericType) && method_param.variable_type is GenericType) {
 					call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (param.name)));
 				} else {
 					call.add_argument (new CCodeIdentifier (param.name));
@@ -2449,9 +2449,9 @@ internal class Vala.DovaBaseModule : CCodeModule {
 
 	public DataType? get_this_type () {
 		if (current_method != null && current_method.binding == MemberBinding.INSTANCE) {
-			return current_method.this_parameter.parameter_type;
+			return current_method.this_parameter.variable_type;
 		} else if (current_property_accessor != null && current_property_accessor.prop.binding == MemberBinding.INSTANCE) {
-			return current_property_accessor.prop.this_parameter.parameter_type;
+			return current_property_accessor.prop.this_parameter.variable_type;
 		}
 		return null;
 	}
diff --git a/codegen/valadovadelegatemodule.vala b/codegen/valadovadelegatemodule.vala
index 6be32ecbf..9e361c43c 100644
--- a/codegen/valadovadelegatemodule.vala
+++ b/codegen/valadovadelegatemodule.vala
@@ -109,14 +109,14 @@ internal class Vala.DovaDelegateModule : DovaValueModule {
 		string param_list = "";
 
 		foreach (FormalParameter param in d.get_parameters ()) {
-			generate_type_declaration (param.parameter_type, decl_space);
+			generate_type_declaration (param.variable_type, decl_space);
 
-			function.add_parameter (new CCodeFormalParameter (param.name, param.parameter_type.get_cname ()));
+			function.add_parameter (new CCodeFormalParameter (param.name, param.variable_type.get_cname ()));
 
 			if (param_list != "") {
 				param_list += ", ";
 			}
-			param_list += param.parameter_type.get_cname ();
+			param_list += param.variable_type.get_cname ();
 		}
 
 		if (d.return_type is GenericType) {
diff --git a/codegen/valadovamemberaccessmodule.vala b/codegen/valadovamemberaccessmodule.vala
index c6ef7e46f..3785932bb 100644
--- a/codegen/valadovamemberaccessmodule.vala
+++ b/codegen/valadovamemberaccessmodule.vala
@@ -237,10 +237,10 @@ internal class Vala.DovaMemberAccessModule : DovaControlFlowModule {
 						// use closure
 						expr.ccodenode = get_variable_cexpression (p.name);
 					} else {
-						var type_as_struct = p.parameter_type.data_type as Struct;
+						var type_as_struct = p.variable_type.data_type as Struct;
 						if (p.direction != ParameterDirection.IN
-						    || (type_as_struct != null && !type_as_struct.is_simple_type () && !p.parameter_type.nullable)) {
-							if (p.parameter_type is GenericType) {
+						    || (type_as_struct != null && !type_as_struct.is_simple_type () && !p.variable_type.nullable)) {
+							if (p.variable_type is GenericType) {
 								expr.ccodenode = get_variable_cexpression (p.name);
 							} else {
 								expr.ccodenode = new CCodeIdentifier ("(*%s)".printf (get_variable_cname (p.name)));
diff --git a/codegen/valadovamethodcallmodule.vala b/codegen/valadovamethodcallmodule.vala
index 149bc89a2..ed4d57133 100644
--- a/codegen/valadovamethodcallmodule.vala
+++ b/codegen/valadovamethodcallmodule.vala
@@ -134,13 +134,13 @@ internal class Vala.DovaMethodCallModule : DovaAssignmentModule {
 					// disabled for arrays for now as that requires special handling
 					// (ret_tmp = call (&tmp), var1 = (assign_tmp = dup (tmp), free (var1), assign_tmp), ret_tmp)
 					if (param.direction != ParameterDirection.IN && requires_destroy (arg.value_type)
-					    && (param.direction == ParameterDirection.OUT || !param.parameter_type.value_owned)
-					    && !(param.parameter_type is ArrayType)) {
+					    && (param.direction == ParameterDirection.OUT || !param.variable_type.value_owned)
+					    && !(param.variable_type is ArrayType)) {
 						var unary = (UnaryExpression) arg;
 
 						var ccomma = new CCodeCommaExpression ();
 
-						var temp_var = get_temp_variable (param.parameter_type, param.parameter_type.value_owned);
+						var temp_var = get_temp_variable (param.variable_type, param.variable_type.value_owned);
 						temp_vars.insert (0, temp_var);
 						cexpr = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, get_variable_cexpression (temp_var.name));
 
@@ -166,7 +166,7 @@ internal class Vala.DovaMethodCallModule : DovaAssignmentModule {
 						var assign_temp_var = get_temp_variable (unary.inner.value_type, unary.inner.value_type.value_owned);
 						temp_vars.insert (0, assign_temp_var);
 
-						cassign_comma.append_expression (new CCodeAssignment (get_variable_cexpression (assign_temp_var.name), transform_expression (get_variable_cexpression (temp_var.name), param.parameter_type, unary.inner.value_type, arg)));
+						cassign_comma.append_expression (new CCodeAssignment (get_variable_cexpression (assign_temp_var.name), transform_expression (get_variable_cexpression (temp_var.name), param.variable_type, unary.inner.value_type, arg)));
 
 						// unref old value
 						cassign_comma.append_expression (get_unref_expression ((CCodeExpression) unary.inner.ccodenode, arg.value_type, arg));
diff --git a/codegen/valadovaobjectmodule.vala b/codegen/valadovaobjectmodule.vala
index 44e07cecf..cf700faf3 100644
--- a/codegen/valadovaobjectmodule.vala
+++ b/codegen/valadovaobjectmodule.vala
@@ -121,14 +121,14 @@ internal class Vala.DovaObjectModule : DovaArrayModule {
 
 		foreach (Field f in cl.get_fields ()) {
 			if (f.binding == MemberBinding.INSTANCE)  {
-				generate_type_declaration (f.field_type, decl_space);
+				generate_type_declaration (f.variable_type, decl_space);
 
-				string field_ctype = f.field_type.get_cname ();
+				string field_ctype = f.variable_type.get_cname ();
 				if (f.is_volatile) {
 					field_ctype = "volatile " + field_ctype;
 				}
 
-				instance_priv_struct.add_field (field_ctype, f.get_cname () + f.field_type.get_cdeclarator_suffix ());
+				instance_priv_struct.add_field (field_ctype, f.get_cname () + f.variable_type.get_cdeclarator_suffix ());
 			}
 		}
 
@@ -1277,7 +1277,7 @@ internal class Vala.DovaObjectModule : DovaArrayModule {
 			string param_list = "(%s *this".printf (((ObjectTypeSymbol) m.parent_symbol).get_cname ());
 			foreach (var param in m.get_parameters ()) {
 				param_list += ", ";
-				param_list += param.parameter_type.get_cname ();
+				param_list += param.variable_type.get_cname ();
 			}
 			if (m.return_type is GenericType) {
 				param_list += ", void *";
@@ -1402,7 +1402,7 @@ internal class Vala.DovaObjectModule : DovaArrayModule {
 						break;
 					}
 
-					var t = param.parameter_type.data_type;
+					var t = param.variable_type.data_type;
 					if (t != null && t.is_reference_type ()) {
 						if (param.direction == ParameterDirection.OUT) {
 							// ensure that the passed reference for output parameter is cleared
@@ -1449,7 +1449,7 @@ internal class Vala.DovaObjectModule : DovaArrayModule {
 				vfunc.add_parameter (new CCodeFormalParameter ("%s_type".printf (type_param.name.down ()), "DovaType*"));
 			}
 			foreach (FormalParameter param in m.get_parameters ()) {
-				string ctypename = param.parameter_type.get_cname ();
+				string ctypename = param.variable_type.get_cname ();
 				if (param.direction != ParameterDirection.IN) {
 					ctypename += "*";
 				}
@@ -1510,7 +1510,7 @@ internal class Vala.DovaObjectModule : DovaArrayModule {
 				vfunc.add_parameter (new CCodeFormalParameter ("%s_type".printf (type_param.name.down ()), "DovaType*"));
 			}
 			foreach (FormalParameter param in m.get_parameters ()) {
-				string ctypename = param.parameter_type.get_cname ();
+				string ctypename = param.variable_type.get_cname ();
 				if (param.direction != ParameterDirection.IN) {
 					ctypename += "*";
 				}
@@ -1548,7 +1548,7 @@ internal class Vala.DovaObjectModule : DovaArrayModule {
 			string param_list = "(%s *this".printf (((ObjectTypeSymbol) m.parent_symbol).get_cname ());
 			foreach (var param in m.get_parameters ()) {
 				param_list += ", ";
-				param_list += param.parameter_type.get_cname ();
+				param_list += param.variable_type.get_cname ();
 			}
 			if (m.return_type is GenericType) {
 				param_list += ", void *";
@@ -1688,11 +1688,11 @@ internal class Vala.DovaObjectModule : DovaArrayModule {
 			// this is only a temporary measure until this can be allocated inline at the end of the instance
 			// this also won't work for subclasses of classes that have fields of generic types
 			foreach (var f in current_class.get_fields ()) {
-				if (f.binding != MemberBinding.INSTANCE || !(f.field_type is GenericType)) {
+				if (f.binding != MemberBinding.INSTANCE || !(f.variable_type is GenericType)) {
 					continue;
 				}
 
-				var generic_type = (GenericType) f.field_type;
+				var generic_type = (GenericType) f.variable_type;
 				var type_get_value_size = new CCodeFunctionCall (new CCodeIdentifier ("dova_type_get_value_size"));
 				type_get_value_size.add_argument (new CCodeIdentifier ("%s_type".printf (generic_type.type_parameter.name.down ())));
 
@@ -1807,11 +1807,11 @@ internal class Vala.DovaObjectModule : DovaArrayModule {
 		foreach (FormalParameter param in m.get_parameters ()) {
 			CCodeFormalParameter cparam;
 			if (!param.ellipsis) {
-				string ctypename = param.parameter_type.get_cname ();
+				string ctypename = param.variable_type.get_cname ();
 
-				generate_type_declaration (param.parameter_type, decl_space);
+				generate_type_declaration (param.variable_type, decl_space);
 
-				if (param.direction != ParameterDirection.IN && !(param.parameter_type is GenericType)) {
+				if (param.direction != ParameterDirection.IN && !(param.variable_type is GenericType)) {
 					ctypename += "*";
 				}
 
diff --git a/codegen/valadovastructmodule.vala b/codegen/valadovastructmodule.vala
index 1497a3a4d..fa01e502a 100644
--- a/codegen/valadovastructmodule.vala
+++ b/codegen/valadovastructmodule.vala
@@ -56,15 +56,15 @@ internal class Vala.DovaStructModule : DovaBaseModule {
 		var instance_struct = new CCodeStruct ("_%s".printf (st.get_cname ()));
 
 		foreach (Field f in st.get_fields ()) {
-			string field_ctype = f.field_type.get_cname ();
+			string field_ctype = f.variable_type.get_cname ();
 			if (f.is_volatile) {
 				field_ctype = "volatile " + field_ctype;
 			}
 
 			if (f.binding == MemberBinding.INSTANCE)  {
-				generate_type_declaration (f.field_type, decl_space);
+				generate_type_declaration (f.variable_type, decl_space);
 
-				instance_struct.add_field (field_ctype, f.get_cname () + f.field_type.get_cdeclarator_suffix ());
+				instance_struct.add_field (field_ctype, f.get_cname () + f.variable_type.get_cdeclarator_suffix ());
 			}
 		}
 
diff --git a/codegen/valadovavaluemodule.vala b/codegen/valadovavaluemodule.vala
index fb3907f31..ba9d2116e 100644
--- a/codegen/valadovavaluemodule.vala
+++ b/codegen/valadovavaluemodule.vala
@@ -301,7 +301,7 @@ internal class Vala.DovaValueModule : DovaObjectModule {
 			if (f.binding == MemberBinding.INSTANCE) {
 				var field = new CCodeMemberAccess.pointer (dest, f.name);
 
-				var array_type = f.field_type as ArrayType;
+				var array_type = f.variable_type as ArrayType;
 				if (array_type != null && array_type.fixed_length) {
 					for (int i = 0; i < array_type.length; i++) {
 						var element = new CCodeElementAccess (field, new CCodeConstant (i.to_string ()));
@@ -313,14 +313,14 @@ internal class Vala.DovaValueModule : DovaObjectModule {
 					continue;
 				}
 
-				if (requires_destroy (f.field_type))  {
+				if (requires_destroy (f.variable_type))  {
 					var this_access = new MemberAccess.simple ("this");
 					this_access.value_type = get_data_type_for_symbol ((TypeSymbol) f.parent_symbol);
 					this_access.ccodenode = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, dest);
 					var ma = new MemberAccess (this_access, f.name);
 					ma.symbol_reference = f;
-					ma.value_type = f.field_type.copy ();
-					cblock.add_statement (new CCodeExpressionStatement (get_unref_expression (field, f.field_type, ma)));
+					ma.value_type = f.variable_type.copy ();
+					cblock.add_statement (new CCodeExpressionStatement (get_unref_expression (field, f.variable_type, ma)));
 				}
 			}
 		}
@@ -335,7 +335,7 @@ internal class Vala.DovaValueModule : DovaObjectModule {
 					CCodeExpression copy = new CCodeMemberAccess.pointer (src, f.name);
 					var dest_field = new CCodeMemberAccess.pointer (dest, f.name);
 
-					var array_type = f.field_type as ArrayType;
+					var array_type = f.variable_type as ArrayType;
 					if (array_type != null && array_type.fixed_length) {
 						for (int i = 0; i < array_type.length; i++) {
 							CCodeExpression copy_element = new CCodeElementAccess (copy, new CCodeConstant (i.to_string ()));
@@ -350,13 +350,13 @@ internal class Vala.DovaValueModule : DovaObjectModule {
 						continue;
 					}
 
-					if (requires_copy (f.field_type))  {
+					if (requires_copy (f.variable_type))  {
 						var this_access = new MemberAccess.simple ("this");
 						this_access.value_type = get_data_type_for_symbol ((TypeSymbol) f.parent_symbol);
 						this_access.ccodenode = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, src);
 						var ma = new MemberAccess (this_access, f.name);
 						ma.symbol_reference = f;
-						copy = get_ref_cexpression (f.field_type, copy, ma, f);
+						copy = get_ref_cexpression (f.variable_type, copy, ma, f);
 					}
 
 					copy_block.add_statement (new CCodeExpressionStatement (new CCodeAssignment (dest_field, copy)));
diff --git a/codegen/valagasyncmodule.vala b/codegen/valagasyncmodule.vala
index ebb142ed6..c406b4b74 100644
--- a/codegen/valagasyncmodule.vala
+++ b/codegen/valagasyncmodule.vala
@@ -41,17 +41,17 @@ public class Vala.GAsyncModule : GSignalModule {
 		}
 
 		foreach (FormalParameter param in m.get_parameters ()) {
-			var param_type = param.parameter_type.copy ();
+			var param_type = param.variable_type.copy ();
 			param_type.value_owned = true;
 			data.add_field (param_type.get_cname (), get_variable_cname (param.name));
 
-			if (param.parameter_type is ArrayType) {
-				var array_type = (ArrayType) param.parameter_type;
+			if (param.variable_type is ArrayType) {
+				var array_type = (ArrayType) param.variable_type;
 				for (int dim = 1; dim <= array_type.rank; dim++) {
 					data.add_field ("gint", get_array_length_cname (get_variable_cname (param.name), dim));
 				}
-			} else if (param.parameter_type is DelegateType) {
-				var deleg_type = (DelegateType) param.parameter_type;
+			} else if (param.variable_type is DelegateType) {
+				var deleg_type = (DelegateType) param.variable_type;
 				if (deleg_type.delegate_symbol.has_target) {
 					data.add_field ("gpointer", get_delegate_target_cname (get_variable_cname (param.name)));
 					data.add_field ("GDestroyNotify", get_delegate_target_destroy_notify_cname (get_variable_cname (param.name)));
@@ -97,14 +97,14 @@ public class Vala.GAsyncModule : GSignalModule {
 
 		foreach (FormalParameter param in m.get_parameters ()) {
 			if (param.direction != ParameterDirection.OUT) {
-				var param_type = param.parameter_type.copy ();
+				var param_type = param.variable_type.copy ();
 				param_type.value_owned = true;
 
 				if (requires_destroy (param_type)) {
 					var ma = new MemberAccess.simple (param.name);
 					ma.symbol_reference = param;
-					ma.value_type = param.parameter_type.copy ();
-					freeblock.add_statement (new CCodeExpressionStatement (get_unref_expression (new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), get_variable_cname (param.name)), param.parameter_type, ma)));
+					ma.value_type = param.variable_type.copy ();
+					freeblock.add_statement (new CCodeExpressionStatement (get_unref_expression (new CCodeMemberAccess.pointer (new CCodeIdentifier ("data"), get_variable_cname (param.name)), param.variable_type, ma)));
 				}
 			}
 		}
@@ -225,28 +225,28 @@ public class Vala.GAsyncModule : GSignalModule {
 
 		foreach (FormalParameter param in m.get_parameters ()) {
 			if (param.direction != ParameterDirection.OUT) {
-				var param_type = param.parameter_type.copy ();
+				var param_type = param.variable_type.copy ();
 				param_type.value_owned = true;
 
 				// create copy if necessary as variables in async methods may need to be kept alive
 				CCodeExpression cparam = get_variable_cexpression (param.name);
-				if (param.parameter_type.is_real_non_null_struct_type ()) {
+				if (param.variable_type.is_real_non_null_struct_type ()) {
 					cparam = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, cparam);
 				}
-				if (requires_copy (param_type) && !param.parameter_type.value_owned)  {
+				if (requires_copy (param_type) && !param.variable_type.value_owned)  {
 					var ma = new MemberAccess.simple (param.name);
 					ma.symbol_reference = param;
-					cparam = get_ref_cexpression (param.parameter_type, cparam, ma, param);
+					cparam = get_ref_cexpression (param.variable_type, cparam, ma, param);
 				}
 
 				asyncblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess.pointer (data_var, get_variable_cname (param.name)), cparam)));
-				if (param.parameter_type is ArrayType) {
-					var array_type = (ArrayType) param.parameter_type;
+				if (param.variable_type is ArrayType) {
+					var array_type = (ArrayType) param.variable_type;
 					for (int dim = 1; dim <= array_type.rank; dim++) {
 						asyncblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess.pointer (data_var, get_array_length_cname (get_variable_cname (param.name), dim)), new CCodeIdentifier (get_array_length_cname (get_variable_cname (param.name), dim)))));
 					}
-				} else if (param.parameter_type is DelegateType) {
-					var deleg_type = (DelegateType) param.parameter_type;
+				} else if (param.variable_type is DelegateType) {
+					var deleg_type = (DelegateType) param.variable_type;
 					if (deleg_type.delegate_symbol.has_target) {
 						asyncblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess.pointer (data_var, get_delegate_target_cname (get_variable_cname (param.name))), new CCodeIdentifier (get_delegate_target_cname (get_variable_cname (param.name))))));
 						if (deleg_type.value_owned) {
@@ -432,7 +432,7 @@ public class Vala.GAsyncModule : GSignalModule {
 		foreach (FormalParameter param in m.get_parameters ()) {
 			if (param.direction != ParameterDirection.IN) {
 				finishblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, new CCodeIdentifier (param.name)), new CCodeMemberAccess.pointer (data_var, get_variable_cname (param.name)))));
-				if (!(param.parameter_type is ValueType) || param.parameter_type.nullable) {
+				if (!(param.variable_type is ValueType) || param.variable_type.nullable) {
 					finishblock.add_statement (new CCodeExpressionStatement (new CCodeAssignment (new CCodeMemberAccess.pointer (data_var, get_variable_cname (param.name)), new CCodeConstant ("NULL"))));
 				}
 			}
diff --git a/codegen/valagdbusclientmodule.vala b/codegen/valagdbusclientmodule.vala
index 1113df6d5..cd4a0ff02 100644
--- a/codegen/valagdbusclientmodule.vala
+++ b/codegen/valagdbusclientmodule.vala
@@ -315,22 +315,22 @@ public class Vala.GDBusClientModule : GDBusModule {
 		ccall.add_argument (sig.get_canonical_cconstant ());
 
 		foreach (FormalParameter param in sig.get_parameters ()) {
-			var owned_type = param.parameter_type.copy ();
+			var owned_type = param.variable_type.copy ();
 			owned_type.value_owned = true;
 
 			cdecl = new CCodeDeclaration (owned_type.get_cname ());
-			cdecl.add_declarator (new CCodeVariableDeclarator.zero (param.name, default_value_for_type (param.parameter_type, true)));
+			cdecl.add_declarator (new CCodeVariableDeclarator.zero (param.name, default_value_for_type (param.variable_type, true)));
 			prefragment.append (cdecl);
 
-			var st = param.parameter_type.data_type as Struct;
+			var st = param.variable_type.data_type as Struct;
 			if (st != null && !st.is_simple_type ()) {
 				ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (param.name)));
 			} else {
 				ccall.add_argument (new CCodeIdentifier (param.name));
 			}
 
-			if (param.parameter_type is ArrayType) {
-				var array_type = (ArrayType) param.parameter_type;
+			if (param.variable_type is ArrayType) {
+				var array_type = (ArrayType) param.variable_type;
 
 				for (int dim = 1; dim <= array_type.rank; dim++) {
 					string length_cname = get_array_length_cname (param.name, dim);
@@ -342,7 +342,7 @@ public class Vala.GDBusClientModule : GDBusModule {
 				}
 			}
 
-			read_expression (prefragment, param.parameter_type, new CCodeIdentifier ("_arguments_iter"), new CCodeIdentifier (param.name), param);
+			read_expression (prefragment, param.variable_type, new CCodeIdentifier ("_arguments_iter"), new CCodeIdentifier (param.name), param);
 
 			if (requires_destroy (owned_type)) {
 				// keep local alive (symbol_reference is weak)
@@ -436,16 +436,16 @@ public class Vala.GDBusClientModule : GDBusModule {
 		foreach (FormalParameter param in m.get_parameters ()) {
 			if (param.direction == ParameterDirection.IN) {
 				CCodeExpression expr = new CCodeIdentifier (param.name);
-				if (param.parameter_type.is_real_struct_type ()) {
+				if (param.variable_type.is_real_struct_type ()) {
 					expr = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, expr);
 				}
-				write_expression (prefragment, param.parameter_type, new CCodeIdentifier ("_arguments_builder"), expr, param);
+				write_expression (prefragment, param.variable_type, new CCodeIdentifier ("_arguments_builder"), expr, param);
 			} else {
-				cdecl = new CCodeDeclaration (param.parameter_type.get_cname ());
+				cdecl = new CCodeDeclaration (param.variable_type.get_cname ());
 				cdecl.add_declarator (new CCodeVariableDeclarator ("_" + param.name));
 				postfragment.append (cdecl);
 
-				var array_type = param.parameter_type as ArrayType;
+				var array_type = param.variable_type as ArrayType;
 
 				if (array_type != null) {
 					for (int dim = 1; dim <= array_type.rank; dim++) {
@@ -456,7 +456,7 @@ public class Vala.GDBusClientModule : GDBusModule {
 				}
 
 				var target = new CCodeIdentifier ("_" + param.name);
-				read_expression (postfragment, param.parameter_type, new CCodeIdentifier ("_reply_iter"), target, param);
+				read_expression (postfragment, param.variable_type, new CCodeIdentifier ("_reply_iter"), target, param);
 
 				// TODO check that parameter is not NULL (out parameters are optional)
 				// free value if parameter is NULL
diff --git a/codegen/valagdbusservermodule.vala b/codegen/valagdbusservermodule.vala
index 1864a1a98..2680a8681 100644
--- a/codegen/valagdbusservermodule.vala
+++ b/codegen/valagdbusservermodule.vala
@@ -137,11 +137,11 @@ public class Vala.GDBusServerModule : GDBusClientModule {
 		ccall.add_argument (new CCodeIdentifier ("self"));
 
 		foreach (FormalParameter param in m.get_parameters ()) {
-			var owned_type = param.parameter_type.copy ();
+			var owned_type = param.variable_type.copy ();
 			owned_type.value_owned = true;
 
 			cdecl = new CCodeDeclaration (owned_type.get_cname ());
-			cdecl.add_declarator (new CCodeVariableDeclarator.zero (param.name, default_value_for_type (param.parameter_type, true)));
+			cdecl.add_declarator (new CCodeVariableDeclarator.zero (param.name, default_value_for_type (param.variable_type, true)));
 			if (param.direction == ParameterDirection.IN) {
 				in_prefragment.append (cdecl);
 			} else {
@@ -149,7 +149,7 @@ public class Vala.GDBusServerModule : GDBusClientModule {
 			}
 
 			if (!m.coroutine || param.direction == ParameterDirection.IN) {
-				var st = param.parameter_type.data_type as Struct;
+				var st = param.variable_type.data_type as Struct;
 				if (param.direction != ParameterDirection.IN
 				    || (st != null && !st.is_simple_type ())) {
 					ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (param.name)));
@@ -160,8 +160,8 @@ public class Vala.GDBusServerModule : GDBusClientModule {
 				finish_ccall.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (param.name)));
 			}
 
-			if (param.parameter_type is ArrayType) {
-				var array_type = (ArrayType) param.parameter_type;
+			if (param.variable_type is ArrayType) {
+				var array_type = (ArrayType) param.variable_type;
 
 				for (int dim = 1; dim <= array_type.rank; dim++) {
 					string length_cname = get_array_length_cname (param.name, dim);
@@ -184,9 +184,9 @@ public class Vala.GDBusServerModule : GDBusClientModule {
 			}
 
 			if (param.direction == ParameterDirection.IN) {
-				read_expression (in_prefragment, param.parameter_type, new CCodeIdentifier ("_arguments_iter"), new CCodeIdentifier (param.name), param);
+				read_expression (in_prefragment, param.variable_type, new CCodeIdentifier ("_arguments_iter"), new CCodeIdentifier (param.name), param);
 			} else {
-				write_expression (out_postfragment, param.parameter_type, new CCodeIdentifier ("_reply_builder"), new CCodeIdentifier (param.name), param);
+				write_expression (out_postfragment, param.variable_type, new CCodeIdentifier ("_reply_builder"), new CCodeIdentifier (param.name), param);
 			}
 
 			if (requires_destroy (owned_type)) {
@@ -370,8 +370,8 @@ public class Vala.GDBusServerModule : GDBusClientModule {
 			generate_parameter (param, source_declarations, new HashMap<int,CCodeFormalParameter> (), null);
 
 			function.add_parameter ((CCodeFormalParameter) get_ccodenode (param));
-			if (param.parameter_type is ArrayType) {
-				var array_type = (ArrayType) param.parameter_type;
+			if (param.variable_type is ArrayType) {
+				var array_type = (ArrayType) param.variable_type;
 				for (int dim = 1; dim <= array_type.rank; dim++) {
 					function.add_parameter (new CCodeFormalParameter (head.get_array_length_cname (param.name, dim), "int"));
 				}
@@ -406,10 +406,10 @@ public class Vala.GDBusServerModule : GDBusClientModule {
 
 		foreach (FormalParameter param in sig.get_parameters ()) {
 			CCodeExpression expr = new CCodeIdentifier (param.name);
-			if (param.parameter_type.is_real_struct_type ()) {
+			if (param.variable_type.is_real_struct_type ()) {
 				expr = new CCodeUnaryExpression (CCodeUnaryOperator.POINTER_INDIRECTION, expr);
 			}
-			write_expression (prefragment, param.parameter_type, new CCodeIdentifier ("_arguments_builder"), expr, param);
+			write_expression (prefragment, param.variable_type, new CCodeIdentifier ("_arguments_builder"), expr, param);
 		}
 
 		var builder_end = new CCodeFunctionCall (new CCodeIdentifier ("g_variant_builder_end"));
@@ -823,7 +823,7 @@ public class Vala.GDBusServerModule : GDBusClientModule {
 				var info = new CCodeInitializerList ();
 				info.append (new CCodeConstant ("-1"));
 				info.append (new CCodeConstant ("\"%s\"".printf (param.name)));
-				info.append (new CCodeConstant ("\"%s\"".printf (get_type_signature (param.parameter_type, param))));
+				info.append (new CCodeConstant ("\"%s\"".printf (get_type_signature (param.variable_type, param))));
 
 				var cdecl = new CCodeDeclaration ("const GDBusArgInfo");
 				cdecl.add_declarator (new CCodeVariableDeclarator ("_" + sym.get_lower_case_cprefix () + "dbus_arg_info_" + m.name + "_" + param.name, info));
@@ -905,7 +905,7 @@ public class Vala.GDBusServerModule : GDBusClientModule {
 				var info = new CCodeInitializerList ();
 				info.append (new CCodeConstant ("-1"));
 				info.append (new CCodeConstant ("\"%s\"".printf (param.name)));
-				info.append (new CCodeConstant ("\"%s\"".printf (get_type_signature (param.parameter_type, param))));
+				info.append (new CCodeConstant ("\"%s\"".printf (get_type_signature (param.variable_type, param))));
 
 				var cdecl = new CCodeDeclaration ("const GDBusArgInfo");
 				cdecl.add_declarator (new CCodeVariableDeclarator ("_" + sym.get_lower_case_cprefix () + "dbus_arg_info_" + sig.get_cname () + "_" + param.name, info));
diff --git a/codegen/valagirwriter.vala b/codegen/valagirwriter.vala
index 601583c86..e1899deec 100644
--- a/codegen/valagirwriter.vala
+++ b/codegen/valagirwriter.vala
@@ -514,7 +514,7 @@ public class Vala.GIRWriter : CodeVisitor {
 
 		write_indent ();
 		buffer.append_printf ("<field name=\"%s\"", f.get_cname ());
-		if (f.field_type.nullable) {
+		if (f.variable_type.nullable) {
 			buffer.append_printf (" allow-none=\"1\"");
 		}
 		buffer.append_printf (">\n");
@@ -522,7 +522,7 @@ public class Vala.GIRWriter : CodeVisitor {
 
 		write_annotations (f);
 
-		write_type (f.field_type);
+		write_type (f.variable_type);
 
 		indent--;
 		write_indent ();
@@ -556,9 +556,9 @@ public class Vala.GIRWriter : CodeVisitor {
 			}
 
 			foreach (FormalParameter param in params) {
-				write_param_or_return (param.parameter_type, "parameter", ref index, !param.no_array_length, param.name, param.direction);
+				write_param_or_return (param.variable_type, "parameter", ref index, !param.no_array_length, param.name, param.direction);
 
-				write_implicit_params (param.parameter_type, ref index, !param.no_array_length, param.name, param.direction);
+				write_implicit_params (param.variable_type, ref index, !param.no_array_length, param.name, param.direction);
 			}
 
 			last_index = index - 1;
diff --git a/codegen/valagsignalmodule.vala b/codegen/valagsignalmodule.vala
index 4b17a81b0..d62b30d8d 100644
--- a/codegen/valagsignalmodule.vala
+++ b/codegen/valagsignalmodule.vala
@@ -67,7 +67,7 @@ public class Vala.GSignalModule : GObjectModule {
 		if (param.direction != ParameterDirection.IN) {
 			return ("POINTER");
 		} else {
-			return get_marshaller_type_name (param.parameter_type, dbus);
+			return get_marshaller_type_name (param.variable_type, dbus);
 		}
 	}
 	
@@ -127,7 +127,7 @@ public class Vala.GSignalModule : GObjectModule {
 		if (p.direction != ParameterDirection.IN) {
 			return "gpointer";
 		} else {
-			return get_value_type_name_from_type_reference (p.parameter_type);
+			return get_value_type_name_from_type_reference (p.variable_type);
 		}
 	}
 	
@@ -212,7 +212,7 @@ public class Vala.GSignalModule : GObjectModule {
 		foreach (FormalParameter p in params) {
 			callback_decl.add_parameter (new CCodeFormalParameter ("arg_%d".printf (n_params), get_value_type_name_from_parameter (p)));
 			n_params++;
-			if (p.parameter_type.is_array () && !dbus) {
+			if (p.variable_type.is_array () && !dbus) {
 				callback_decl.add_parameter (new CCodeFormalParameter ("arg_%d".printf (n_params), "gint"));
 				n_params++;
 			}
@@ -272,34 +272,34 @@ public class Vala.GSignalModule : GObjectModule {
 		i = 1;
 		foreach (FormalParameter p in params) {
 			string get_value_function;
-			bool is_array = p.parameter_type.is_array ();
+			bool is_array = p.variable_type.is_array ();
 			if (p.direction != ParameterDirection.IN) {
 				get_value_function = "g_value_get_pointer";
 			} else if (is_array) {
 				if (dbus) {
 					get_value_function = "g_value_get_boxed";
 				} else {
-					if (((ArrayType) p.parameter_type).element_type.data_type == string_type.data_type) {
+					if (((ArrayType) p.variable_type).element_type.data_type == string_type.data_type) {
 						get_value_function = "g_value_get_boxed";
 					} else {
 						get_value_function = "g_value_get_pointer";
 					}
 				}
-			} else if (p.parameter_type is PointerType || p.parameter_type.type_parameter != null) {
+			} else if (p.variable_type is PointerType || p.variable_type.type_parameter != null) {
 				get_value_function = "g_value_get_pointer";
-			} else if (p.parameter_type is ErrorType) {
+			} else if (p.variable_type is ErrorType) {
 				get_value_function = "g_value_get_pointer";
-			} else if (dbus && DBusModule.get_type_signature (p.parameter_type).has_prefix ("(")) {
+			} else if (dbus && DBusModule.get_type_signature (p.variable_type).has_prefix ("(")) {
 				get_value_function = "g_value_get_boxed";
-			} else if (dbus && p.parameter_type.data_type is Enum) {
-				var en = (Enum) p.parameter_type.data_type;
+			} else if (dbus && p.variable_type.data_type is Enum) {
+				var en = (Enum) p.variable_type.data_type;
 				if (en.is_flags) {
 					get_value_function = "g_value_get_uint";
 				} else {
 					get_value_function = "g_value_get_int";
 				}
 			} else {
-				get_value_function = p.parameter_type.data_type.get_get_value_function ();
+				get_value_function = p.variable_type.data_type.get_get_value_function ();
 			}
 			var inner_fc = new CCodeFunctionCall (new CCodeIdentifier (get_value_function));
 			inner_fc.add_argument (new CCodeBinaryExpression (CCodeBinaryOperator.PLUS, new CCodeIdentifier ("param_values"), new CCodeIdentifier (i.to_string ())));
@@ -423,26 +423,26 @@ public class Vala.GSignalModule : GObjectModule {
 		int params_len = 0;
 		foreach (FormalParameter param in params) {
 			params_len++;
-			if (param.parameter_type.is_array ()) {
+			if (param.variable_type.is_array ()) {
 				params_len++;
 			}
 		}
 
 		csignew.add_argument (new CCodeConstant ("%d".printf (params_len)));
 		foreach (FormalParameter param in params) {
-			if (param.parameter_type.is_array ()) {
-				if (((ArrayType) param.parameter_type).element_type.data_type == string_type.data_type) {
+			if (param.variable_type.is_array ()) {
+				if (((ArrayType) param.variable_type).element_type.data_type == string_type.data_type) {
 					csignew.add_argument (new CCodeConstant ("G_TYPE_STRV"));
 				} else {
 					csignew.add_argument (new CCodeConstant ("G_TYPE_POINTER"));
 				}
 				csignew.add_argument (new CCodeConstant ("G_TYPE_INT"));
-			} else if (param.parameter_type is PointerType || param.parameter_type.type_parameter != null || param.direction != ParameterDirection.IN) {
+			} else if (param.variable_type is PointerType || param.variable_type.type_parameter != null || param.direction != ParameterDirection.IN) {
 				csignew.add_argument (new CCodeConstant ("G_TYPE_POINTER"));
-			} else if (param.parameter_type is ErrorType) {
+			} else if (param.variable_type is ErrorType) {
 				csignew.add_argument (new CCodeConstant ("G_TYPE_POINTER"));
 			} else {
-				csignew.add_argument (new CCodeConstant (param.parameter_type.data_type.get_type_id ()));
+				csignew.add_argument (new CCodeConstant (param.variable_type.data_type.get_type_id ()));
 			}
 		}
 
@@ -478,7 +478,7 @@ public class Vala.GSignalModule : GObjectModule {
 	bool in_gobject_instance (Method m) {
 		bool result = false;
 		if (m.binding == MemberBinding.INSTANCE) {
-			result = m.this_parameter.parameter_type.data_type.is_subtype_of (gobject_type);
+			result = m.this_parameter.variable_type.data_type.is_subtype_of (gobject_type);
 		}
 		return result;
 	}
diff --git a/codegen/valagtypemodule.vala b/codegen/valagtypemodule.vala
index 50c7cdcde..e2a001e0f 100644
--- a/codegen/valagtypemodule.vala
+++ b/codegen/valagtypemodule.vala
@@ -29,14 +29,14 @@ public class Vala.GTypeModule : GErrorModule {
 	}
 
 	public override void generate_parameter (FormalParameter param, CCodeDeclarationSpace decl_space, Map<int,CCodeFormalParameter> cparam_map, Map<int,CCodeExpression>? carg_map) {
-		if (!(param.parameter_type is ObjectType)) {
+		if (!(param.variable_type is ObjectType)) {
 			base.generate_parameter (param, decl_space, cparam_map, carg_map);
 			return;
 		}
 
-		generate_type_declaration (param.parameter_type, decl_space);
+		generate_type_declaration (param.variable_type, decl_space);
 
-		string ctypename = param.parameter_type.get_cname ();
+		string ctypename = param.variable_type.get_cname ();
 
 		if (param.direction != ParameterDirection.IN) {
 			ctypename += "*";
@@ -302,19 +302,19 @@ public class Vala.GTypeModule : GErrorModule {
 		}
 
 		foreach (Field f in cl.get_fields ()) {
-			string field_ctype = f.field_type.get_cname ();
+			string field_ctype = f.variable_type.get_cname ();
 			if (f.is_volatile) {
 				field_ctype = "volatile " + field_ctype;
 			}
 
 			if (f.access != SymbolAccessibility.PRIVATE) {
 				if (f.binding == MemberBinding.INSTANCE) {
-					generate_type_declaration (f.field_type, decl_space);
+					generate_type_declaration (f.variable_type, decl_space);
 
-					instance_struct.add_field (field_ctype, f.get_cname (), f.field_type.get_cdeclarator_suffix ());
-					if (f.field_type is ArrayType && !f.no_array_length) {
+					instance_struct.add_field (field_ctype, f.get_cname (), f.variable_type.get_cdeclarator_suffix ());
+					if (f.variable_type is ArrayType && !f.no_array_length) {
 						// create fields to store array dimensions
-						var array_type = (ArrayType) f.field_type;
+						var array_type = (ArrayType) f.variable_type;
 
 						if (!array_type.fixed_length) {
 							var len_type = int_type.copy ();
@@ -327,8 +327,8 @@ public class Vala.GTypeModule : GErrorModule {
 								instance_struct.add_field (len_type.get_cname (), head.get_array_size_cname (f.name));
 							}
 						}
-					} else if (f.field_type is DelegateType) {
-						var delegate_type = (DelegateType) f.field_type;
+					} else if (f.variable_type is DelegateType) {
+						var delegate_type = (DelegateType) f.variable_type;
 						if (delegate_type.delegate_symbol.has_target) {
 							// create field to store delegate target
 							instance_struct.add_field ("gpointer", get_delegate_target_cname (f.name));
@@ -404,19 +404,19 @@ public class Vala.GTypeModule : GErrorModule {
 		}
 
 		foreach (Field f in cl.get_fields ()) {
-			string field_ctype = f.field_type.get_cname ();
+			string field_ctype = f.variable_type.get_cname ();
 			if (f.is_volatile) {
 				field_ctype = "volatile " + field_ctype;
 			}
 
 			if (f.binding == MemberBinding.INSTANCE) {
 				if (f.access == SymbolAccessibility.PRIVATE)  {
-					generate_type_declaration (f.field_type, decl_space);
+					generate_type_declaration (f.variable_type, decl_space);
 
-					instance_priv_struct.add_field (field_ctype, f.get_cname (), f.field_type.get_cdeclarator_suffix ());
-					if (f.field_type is ArrayType && !f.no_array_length) {
+					instance_priv_struct.add_field (field_ctype, f.get_cname (), f.variable_type.get_cdeclarator_suffix ());
+					if (f.variable_type is ArrayType && !f.no_array_length) {
 						// create fields to store array dimensions
-						var array_type = (ArrayType) f.field_type;
+						var array_type = (ArrayType) f.variable_type;
 						var len_type = int_type.copy ();
 
 						if (!array_type.fixed_length) {
@@ -428,8 +428,8 @@ public class Vala.GTypeModule : GErrorModule {
 								instance_priv_struct.add_field (len_type.get_cname (), head.get_array_size_cname (f.name));
 							}
 						}
-					} else if (f.field_type is DelegateType) {
-						var delegate_type = (DelegateType) f.field_type;
+					} else if (f.variable_type is DelegateType) {
+						var delegate_type = (DelegateType) f.variable_type;
 						if (delegate_type.delegate_symbol.has_target) {
 							// create field to store delegate target
 							instance_priv_struct.add_field ("gpointer", get_delegate_target_cname (f.name));
@@ -1662,8 +1662,8 @@ public class Vala.GTypeModule : GErrorModule {
 				}
 			}
 
-			if (prop.default_expression != null) {
-				cspec.add_argument ((CCodeExpression) prop.default_expression.ccodenode);
+			if (prop.initializer != null) {
+				cspec.add_argument ((CCodeExpression) prop.initializer.ccodenode);
 			} else {
 				cspec.add_argument (new CCodeConstant (prop.property_type.data_type.get_default_value ()));
 			}
@@ -1673,8 +1673,8 @@ public class Vala.GTypeModule : GErrorModule {
 				cspec.call = new CCodeIdentifier ("g_param_spec_int");
 				cspec.add_argument (new CCodeConstant ("G_MININT"));
 				cspec.add_argument (new CCodeConstant ("G_MAXINT"));
-				if (prop.default_expression != null) {
-					cspec.add_argument ((CCodeExpression) prop.default_expression.ccodenode);
+				if (prop.initializer != null) {
+					cspec.add_argument ((CCodeExpression) prop.initializer.ccodenode);
 				} else {
 					cspec.add_argument (new CCodeConstant ("0"));
 				}
@@ -1682,8 +1682,8 @@ public class Vala.GTypeModule : GErrorModule {
 				cspec.call = new CCodeIdentifier ("g_param_spec_uint");
 				cspec.add_argument (new CCodeConstant ("0"));
 				cspec.add_argument (new CCodeConstant ("G_MAXUINT"));
-				if (prop.default_expression != null) {
-					cspec.add_argument ((CCodeExpression) prop.default_expression.ccodenode);
+				if (prop.initializer != null) {
+					cspec.add_argument ((CCodeExpression) prop.initializer.ccodenode);
 				} else {
 					cspec.add_argument (new CCodeConstant ("0U"));
 				}
@@ -1691,8 +1691,8 @@ public class Vala.GTypeModule : GErrorModule {
 				cspec.call = new CCodeIdentifier ("g_param_spec_int64");
 				cspec.add_argument (new CCodeConstant ("G_MININT64"));
 				cspec.add_argument (new CCodeConstant ("G_MAXINT64"));
-				if (prop.default_expression != null) {
-					cspec.add_argument ((CCodeExpression) prop.default_expression.ccodenode);
+				if (prop.initializer != null) {
+					cspec.add_argument ((CCodeExpression) prop.initializer.ccodenode);
 				} else {
 					cspec.add_argument (new CCodeConstant ("0"));
 				}
@@ -1700,8 +1700,8 @@ public class Vala.GTypeModule : GErrorModule {
 				cspec.call = new CCodeIdentifier ("g_param_spec_uint64");
 				cspec.add_argument (new CCodeConstant ("0"));
 				cspec.add_argument (new CCodeConstant ("G_MAXUINT64"));
-				if (prop.default_expression != null) {
-					cspec.add_argument ((CCodeExpression) prop.default_expression.ccodenode);
+				if (prop.initializer != null) {
+					cspec.add_argument ((CCodeExpression) prop.initializer.ccodenode);
 				} else {
 					cspec.add_argument (new CCodeConstant ("0U"));
 				}
@@ -1709,8 +1709,8 @@ public class Vala.GTypeModule : GErrorModule {
 				cspec.call = new CCodeIdentifier ("g_param_spec_long");
 				cspec.add_argument (new CCodeConstant ("G_MINLONG"));
 				cspec.add_argument (new CCodeConstant ("G_MAXLONG"));
-				if (prop.default_expression != null) {
-					cspec.add_argument ((CCodeExpression) prop.default_expression.ccodenode);
+				if (prop.initializer != null) {
+					cspec.add_argument ((CCodeExpression) prop.initializer.ccodenode);
 				} else {
 					cspec.add_argument (new CCodeConstant ("0L"));
 				}
@@ -1718,15 +1718,15 @@ public class Vala.GTypeModule : GErrorModule {
 				cspec.call = new CCodeIdentifier ("g_param_spec_ulong");
 				cspec.add_argument (new CCodeConstant ("0"));
 				cspec.add_argument (new CCodeConstant ("G_MAXULONG"));
-				if (prop.default_expression != null) {
-					cspec.add_argument ((CCodeExpression) prop.default_expression.ccodenode);
+				if (prop.initializer != null) {
+					cspec.add_argument ((CCodeExpression) prop.initializer.ccodenode);
 				} else {
 					cspec.add_argument (new CCodeConstant ("0UL"));
 				}
 			} else if (st.get_type_id () == "G_TYPE_BOOLEAN") {
 				cspec.call = new CCodeIdentifier ("g_param_spec_boolean");
-				if (prop.default_expression != null) {
-					cspec.add_argument ((CCodeExpression) prop.default_expression.ccodenode);
+				if (prop.initializer != null) {
+					cspec.add_argument ((CCodeExpression) prop.initializer.ccodenode);
 				} else {
 					cspec.add_argument (new CCodeConstant ("FALSE"));
 				}
@@ -1734,8 +1734,8 @@ public class Vala.GTypeModule : GErrorModule {
 				cspec.call = new CCodeIdentifier ("g_param_spec_char");
 				cspec.add_argument (new CCodeConstant ("G_MININT8"));
 				cspec.add_argument (new CCodeConstant ("G_MAXINT8"));
-				if (prop.default_expression != null) {
-					cspec.add_argument ((CCodeExpression) prop.default_expression.ccodenode);
+				if (prop.initializer != null) {
+					cspec.add_argument ((CCodeExpression) prop.initializer.ccodenode);
 				} else {
 					cspec.add_argument (new CCodeConstant ("0"));
 				}
@@ -1743,8 +1743,8 @@ public class Vala.GTypeModule : GErrorModule {
 				cspec.call = new CCodeIdentifier ("g_param_spec_uchar");
 				cspec.add_argument (new CCodeConstant ("0"));
 				cspec.add_argument (new CCodeConstant ("G_MAXUINT8"));
-				if (prop.default_expression != null) {
-					cspec.add_argument ((CCodeExpression) prop.default_expression.ccodenode);
+				if (prop.initializer != null) {
+					cspec.add_argument ((CCodeExpression) prop.initializer.ccodenode);
 				} else {
 					cspec.add_argument (new CCodeConstant ("0"));
 				}
@@ -1752,8 +1752,8 @@ public class Vala.GTypeModule : GErrorModule {
 				cspec.call = new CCodeIdentifier ("g_param_spec_float");
 				cspec.add_argument (new CCodeConstant ("-G_MAXFLOAT"));
 				cspec.add_argument (new CCodeConstant ("G_MAXFLOAT"));
-				if (prop.default_expression != null) {
-					cspec.add_argument ((CCodeExpression) prop.default_expression.ccodenode);
+				if (prop.initializer != null) {
+					cspec.add_argument ((CCodeExpression) prop.initializer.ccodenode);
 				} else {
 					cspec.add_argument (new CCodeConstant ("0.0F"));
 				}
@@ -1761,15 +1761,15 @@ public class Vala.GTypeModule : GErrorModule {
 				cspec.call = new CCodeIdentifier ("g_param_spec_double");
 				cspec.add_argument (new CCodeConstant ("-G_MAXDOUBLE"));
 				cspec.add_argument (new CCodeConstant ("G_MAXDOUBLE"));
-				if (prop.default_expression != null) {
-					cspec.add_argument ((CCodeExpression) prop.default_expression.ccodenode);
+				if (prop.initializer != null) {
+					cspec.add_argument ((CCodeExpression) prop.initializer.ccodenode);
 				} else {
 					cspec.add_argument (new CCodeConstant ("0.0"));
 				}
 			} else if (st.get_type_id () == "G_TYPE_GTYPE") {
 				cspec.call = new CCodeIdentifier ("g_param_spec_gtype");
-				if (prop.default_expression != null) {
-					cspec.add_argument ((CCodeExpression) prop.default_expression.ccodenode);
+				if (prop.initializer != null) {
+					cspec.add_argument ((CCodeExpression) prop.initializer.ccodenode);
 				} else {
 					cspec.add_argument (new CCodeConstant ("G_TYPE_NONE"));
 				}
diff --git a/codegen/valagvariantmodule.vala b/codegen/valagvariantmodule.vala
index 0694edf57..e44c49539 100644
--- a/codegen/valagvariantmodule.vala
+++ b/codegen/valagvariantmodule.vala
@@ -122,7 +122,7 @@ public class Vala.GVariantModule : GAsyncModule {
 				str.append_c ('(');
 				foreach (Field f in st.get_fields ()) {
 					if (f.binding == MemberBinding.INSTANCE) {
-						str.append (get_type_signature (f.field_type));
+						str.append (get_type_signature (f.variable_type));
 					}
 				}
 				str.append_c (')');
@@ -397,7 +397,7 @@ public class Vala.GVariantModule : GAsyncModule {
 
 			field_found = true;
 
-			read_expression (fragment, f.field_type, new CCodeIdentifier (subiter_name), new CCodeMemberAccess (new CCodeIdentifier (temp_name), f.get_cname ()), f);
+			read_expression (fragment, f.variable_type, new CCodeIdentifier (subiter_name), new CCodeMemberAccess (new CCodeIdentifier (temp_name), f.get_cname ()), f);
 		}
 
 		if (!field_found) {
@@ -685,7 +685,7 @@ public class Vala.GVariantModule : GAsyncModule {
 
 			field_found = true;
 
-			write_expression (fragment, f.field_type, new CCodeIdentifier (builder_name), new CCodeMemberAccess (struct_expr, f.get_cname ()), f);
+			write_expression (fragment, f.variable_type, new CCodeIdentifier (builder_name), new CCodeMemberAccess (struct_expr, f.get_cname ()), f);
 		}
 
 		if (!field_found) {
diff --git a/vala/Makefile.am b/vala/Makefile.am
index 1dc0ca857..7148e44fe 100644
--- a/vala/Makefile.am
+++ b/vala/Makefile.am
@@ -156,6 +156,7 @@ libvalacore_la_VALASOURCES = \
 	valaunresolvedtype.vala \
 	valausingdirective.vala \
 	valavaluetype.vala \
+	valavariable.vala \
 	valavoidtype.vala \
 	valawhilestatement.vala \
 	valayieldstatement.vala \
diff --git a/vala/valaarraytype.vala b/vala/valaarraytype.vala
index c1d9e0e04..ee57df57d 100644
--- a/vala/valaarraytype.vala
+++ b/vala/valaarraytype.vala
@@ -88,9 +88,9 @@ public class Vala.ArrayType : ReferenceType {
 			if (rank > 1) {
 				// length is an int[] containing the dimensions of the array, starting at 0
 				ValueType integer = new IntegerType ((Struct) root_symbol.scope.lookup ("int"));
-				length_field.field_type = new ArrayType (integer, 1, source_reference);
+				length_field.variable_type = new ArrayType (integer, 1, source_reference);
 			} else {
-				length_field.field_type = new IntegerType ((Struct) root_symbol.scope.lookup ("int"));
+				length_field.variable_type = new IntegerType ((Struct) root_symbol.scope.lookup ("int"));
 			}
 
 		}
diff --git a/vala/valaassignment.vala b/vala/valaassignment.vala
index 7cb5b1f25..66c93165a 100644
--- a/vala/valaassignment.vala
+++ b/vala/valaassignment.vala
@@ -347,9 +347,9 @@ public class Vala.Assignment : Expression {
 				var f = (Field) ma.symbol_reference;
 
 				if (right.symbol_reference is Method &&
-				    f.field_type is DelegateType) {
+				    f.variable_type is DelegateType) {
 					var m = (Method) right.symbol_reference;
-					var dt = (DelegateType) f.field_type;
+					var dt = (DelegateType) f.variable_type;
 					var cb = dt.delegate_symbol;
 
 					/* check whether method matches callback type */
@@ -359,7 +359,7 @@ public class Vala.Assignment : Expression {
 						return false;
 					}
 
-					right.value_type = f.field_type;
+					right.value_type = f.variable_type;
 				} else {
 					error = true;
 					Report.error (source_reference, "Assignment: Invalid callback assignment attempt");
diff --git a/vala/valaclass.vala b/vala/valaclass.vala
index fb0ce37cc..1fb579833 100644
--- a/vala/valaclass.vala
+++ b/vala/valaclass.vala
@@ -291,7 +291,7 @@ public class Vala.Class : ObjectTypeSymbol {
 		    name != "any" /* temporary workaround */) {
 			// public/protected instance fields not supported, convert to automatic property
 
-			var prop = new Property (f.name, f.field_type.copy (), null, null, f.source_reference, comment);
+			var prop = new Property (f.name, f.variable_type.copy (), null, null, f.source_reference, comment);
 			prop.access = access;
 
 			var get_type = prop.property_type.copy ();
diff --git a/vala/valacodewriter.vala b/vala/valacodewriter.vala
index e72545885..89d848fdc 100644
--- a/vala/valacodewriter.vala
+++ b/vala/valacodewriter.vala
@@ -673,7 +673,7 @@ public class Vala.CodeWriter : CodeVisitor {
 		bool custom_cheaders = (f.parent_symbol is Namespace);
 		bool custom_array_length_cname = (f.get_array_length_cname () != null);
 		bool custom_array_length_type = (f.array_length_type != null);
-		if (custom_cname || custom_ctype || custom_cheaders || custom_array_length_cname || custom_array_length_type || (f.no_array_length && f.field_type is ArrayType)) {
+		if (custom_cname || custom_ctype || custom_cheaders || custom_array_length_cname || custom_array_length_type || (f.no_array_length && f.variable_type is ArrayType)) {
 			write_indent ();
 			write_string ("[CCode (");
 
@@ -697,7 +697,7 @@ public class Vala.CodeWriter : CodeVisitor {
 				write_string ("cheader_filename = \"%s\"".printf (get_cheaders(f)));
 			}
 
-			if (f.field_type is ArrayType) {
+			if (f.variable_type is ArrayType) {
 				if (f.no_array_length) {
 					if (custom_cname || custom_ctype || custom_cheaders) {
 						write_string (", ");
@@ -739,11 +739,11 @@ public class Vala.CodeWriter : CodeVisitor {
 			write_string ("class ");
 		}
 
-		if (is_weak (f.field_type)) {
+		if (is_weak (f.variable_type)) {
 			write_string ("weak ");
 		}
 
-		write_type (f.field_type);
+		write_type (f.variable_type);
 			
 		write_string (" ");
 		write_identifier (f.name);
@@ -799,11 +799,11 @@ public class Vala.CodeWriter : CodeVisitor {
 				ccode_params.append_printf ("%stype = \"%s\"", separator, param.ctype);
 				separator = ", ";
 			}
-			if (param.no_array_length && param.parameter_type is ArrayType) {
+			if (param.no_array_length && param.variable_type is ArrayType) {
 				ccode_params.append_printf ("%sarray_length = false", separator);
 				separator = ", ";
 			}
-			if (param.array_length_type != null && param.parameter_type is ArrayType) {
+			if (param.array_length_type != null && param.variable_type is ArrayType) {
 				ccode_params.append_printf ("%sarray_length_type = \"%s\"", separator, param.array_length_type);
 				separator = ", ";
 			}
@@ -825,7 +825,7 @@ public class Vala.CodeWriter : CodeVisitor {
 			}
 
 			if (param.direction == ParameterDirection.IN) {
-				if (param.parameter_type.value_owned) {
+				if (param.variable_type.value_owned) {
 					write_string ("owned ");
 				}
 			} else {
@@ -834,19 +834,19 @@ public class Vala.CodeWriter : CodeVisitor {
 				} else if (param.direction == ParameterDirection.OUT) {
 					write_string ("out ");
 				}
-				if (is_weak (param.parameter_type)) {
+				if (is_weak (param.variable_type)) {
 					write_string ("unowned ");
 				}
 			}
 
-			write_type (param.parameter_type);
+			write_type (param.variable_type);
 
 			write_string (" ");
 			write_identifier (param.name);
 			
-			if (param.default_expression != null) {
+			if (param.initializer != null) {
 				write_string (" = ");
-				write_string (param.default_expression.to_string ());
+				write_string (param.initializer.to_string ());
 			}
 
 			i++;
diff --git a/vala/valadelegate.vala b/vala/valadelegate.vala
index 85ada07cc..27c660ccc 100644
--- a/vala/valadelegate.vala
+++ b/vala/valadelegate.vala
@@ -171,7 +171,7 @@ public class Vala.Delegate : TypeSymbol {
 
 			// method is allowed to accept arguments of looser types (weaker precondition)
 			var method_param = method_params_it.get ();
-			if (!sender_type.stricter (method_param.parameter_type)) {
+			if (!sender_type.stricter (method_param.variable_type)) {
 				return false;
 			}
 		}
@@ -194,7 +194,7 @@ public class Vala.Delegate : TypeSymbol {
 
 			// method is allowed to accept arguments of looser types (weaker precondition)
 			var method_param = method_params_it.get ();
-			if (!param.parameter_type.get_actual_type (dt, null, this).stricter (method_param.parameter_type)) {
+			if (!param.variable_type.get_actual_type (dt, null, this).stricter (method_param.variable_type)) {
 				return false;
 			}
 		}
@@ -355,7 +355,7 @@ public class Vala.Delegate : TypeSymbol {
 			}
 
 			if (param.direction == ParameterDirection.IN) {
-				if (param.parameter_type.value_owned) {
+				if (param.variable_type.value_owned) {
 					str += "owned ";
 				}
 			} else {
@@ -364,12 +364,12 @@ public class Vala.Delegate : TypeSymbol {
 				} else if (param.direction == ParameterDirection.OUT) {
 					str += "out ";
 				}
-				if (!param.parameter_type.value_owned && param.parameter_type is ReferenceType) {
+				if (!param.variable_type.value_owned && param.variable_type is ReferenceType) {
 					str += "weak ";
 				}
 			}
 
-			str += param.parameter_type.to_string ();
+			str += param.variable_type.to_string ();
 
 			i++;
 		}
diff --git a/vala/valafield.vala b/vala/valafield.vala
index 85029d23b..07281f246 100644
--- a/vala/valafield.vala
+++ b/vala/valafield.vala
@@ -25,31 +25,7 @@ using GLib;
 /**
  * Represents a type or namespace field.
  */
-public class Vala.Field : Symbol, Lockable {
-	/**
-	 * The data type of this field.
-	 */
-	public DataType field_type {
-		get { return _data_type; }
-		set {
-			_data_type = value;
-			_data_type.parent_node = this;
-		}
-	}
-
-	/**
-	 * Specifies the expression to be used to initialize this field.
-	 */
-	public Expression? initializer { 
-		get { return _initializer; }
-		set {
-			_initializer = value;
-			if (_initializer != null) {
-				_initializer.parent_node = this;
-			}
-		}
-	}
-
+public class Vala.Field : Variable, Lockable {
 	/**
 	 * Specifies whether this field may only be accessed with an instance of
 	 * the contained type.
@@ -106,10 +82,6 @@ public class Vala.Field : Symbol, Lockable {
 	
 	private bool lock_used = false;
 
-	private Expression _initializer;
-
-	private DataType _data_type;
-
 	/**
 	 * Creates a new field.
 	 *
@@ -119,10 +91,8 @@ public class Vala.Field : Symbol, Lockable {
 	 * @param source reference to source code
 	 * @return       newly created field
 	 */
-	public Field (string name, DataType field_type, Expression? initializer, SourceReference? source_reference = null, Comment? comment = null) {
-		base (name, source_reference, comment);
-		this.field_type = field_type;
-		this.initializer = initializer;
+	public Field (string name, DataType variable_type, Expression? initializer, SourceReference? source_reference = null, Comment? comment = null) {
+		base (variable_type, name, initializer, source_reference, comment);
 	}
 
 	public override void accept (CodeVisitor visitor) {
@@ -130,7 +100,7 @@ public class Vala.Field : Symbol, Lockable {
 	}
 
 	public override void accept_children (CodeVisitor visitor) {
-		field_type.accept (visitor);
+		variable_type.accept (visitor);
 		
 		if (initializer != null) {
 			initializer.accept (visitor);
@@ -268,8 +238,8 @@ public class Vala.Field : Symbol, Lockable {
 	}
 
 	public override void replace_type (DataType old_type, DataType new_type) {
-		if (field_type == old_type) {
-			field_type = new_type;
+		if (variable_type == old_type) {
+			variable_type = new_type;
 		}
 	}
 
@@ -305,19 +275,19 @@ public class Vala.Field : Symbol, Lockable {
 		}
 		analyzer.current_symbol = this;
 
-		field_type.check (analyzer);
+		variable_type.check (analyzer);
 
 		// check whether field type is at least as accessible as the field
-		if (!analyzer.is_type_accessible (this, field_type)) {
+		if (!analyzer.is_type_accessible (this, variable_type)) {
 			error = true;
-			Report.error (source_reference, "field type `%s` is less accessible than field `%s`".printf (field_type.to_string (), get_full_name ()));
+			Report.error (source_reference, "field type `%s` is less accessible than field `%s`".printf (variable_type.to_string (), get_full_name ()));
 			return false;
 		}
 
 		process_attributes ();
 
 		if (initializer != null) {
-			initializer.target_type = field_type;
+			initializer.target_type = variable_type;
 
 			if (!initializer.check (analyzer)) {
 				error = true;
@@ -330,9 +300,9 @@ public class Vala.Field : Symbol, Lockable {
 				return false;
 			}
 
-			if (!initializer.value_type.compatible (field_type)) {
+			if (!initializer.value_type.compatible (variable_type)) {
 				error = true;
-				Report.error (source_reference, "Cannot convert from `%s' to `%s'".printf (initializer.value_type.to_string (), field_type.to_string ()));
+				Report.error (source_reference, "Cannot convert from `%s' to `%s'".printf (initializer.value_type.to_string (), variable_type.to_string ()));
 				return false;
 			}
 
diff --git a/vala/valaformalparameter.vala b/vala/valaformalparameter.vala
index e01ad49fa..605af0349 100644
--- a/vala/valaformalparameter.vala
+++ b/vala/valaformalparameter.vala
@@ -27,18 +27,7 @@ using GLib;
 /**
  * Represents a formal parameter in method and callback signatures.
  */
-public class Vala.FormalParameter : Symbol {
-	/**
-	 * The parameter type.
-	 */
-	public DataType parameter_type {
-		get { return _data_type; }
-		set {
-			_data_type = value;
-			_data_type.parent_node = this;
-		}
-	}
-
+public class Vala.FormalParameter : Variable {
 	public ParameterDirection direction { get; set; default = ParameterDirection.IN; }
 
 	/**
@@ -54,20 +43,6 @@ public class Vala.FormalParameter : Symbol {
 	public bool params_array { get; set; }
 	
 	/**
-	 * Specifies the expression used when the caller doesn't supply an
-	 * argument for this parameter.
-	 */
-	public Expression? default_expression {
-		get { return _default_expression; }
-		set {
-			_default_expression = value;
-			if (_default_expression != null) {
-				_default_expression.parent_node = this;
-			}
-		}
-	}
-	
-	/**
 	 * Specifies whether the array length should be passed implicitly
 	 * if the parameter type is an array.
 	 */
@@ -109,9 +84,6 @@ public class Vala.FormalParameter : Symbol {
 
 	public bool captured { get; set; }
 
-	private DataType _data_type;
-	private Expression? _default_expression;
-
 	/**
 	 * Creates a new formal parameter.
 	 *
@@ -120,9 +92,8 @@ public class Vala.FormalParameter : Symbol {
 	 * @param source reference to source code
 	 * @return       newly created formal parameter
 	 */
-	public FormalParameter (string name, DataType parameter_type, SourceReference? source_reference = null) {
-		base (name, source_reference);
-		this.parameter_type = parameter_type;
+	public FormalParameter (string name, DataType variable_type, SourceReference? source_reference = null) {
+		base (variable_type, name, null, source_reference);
 
 		access = SymbolAccessibility.PUBLIC;
 	}
@@ -132,7 +103,7 @@ public class Vala.FormalParameter : Symbol {
 	 * parameters.
 	 */
 	public FormalParameter.with_ellipsis (SourceReference? source_reference = null) {
-		base (null, source_reference);
+		base (null, null, null, source_reference);
 		ellipsis = true;
 
 		access = SymbolAccessibility.PUBLIC;
@@ -144,23 +115,23 @@ public class Vala.FormalParameter : Symbol {
 
 	public override void accept_children (CodeVisitor visitor) {
 		if (!ellipsis) {
-			parameter_type.accept (visitor);
+			variable_type.accept (visitor);
 			
-			if (default_expression != null) {
-				default_expression.accept (visitor);
+			if (initializer != null) {
+				initializer.accept (visitor);
 			}
 		}
 	}
 
 	public override void replace_type (DataType old_type, DataType new_type) {
-		if (parameter_type == old_type) {
-			parameter_type = new_type;
+		if (variable_type == old_type) {
+			variable_type = new_type;
 		}
 	}
 
 	public override void replace_expression (Expression old_node, Expression new_node) {
-		if (default_expression == old_node) {
-			default_expression = new_node;
+		if (initializer == old_node) {
+			initializer = new_node;
 		}
 	}
 
@@ -204,10 +175,10 @@ public class Vala.FormalParameter : Symbol {
 
 	public FormalParameter copy () {
 		if (!ellipsis) {
-			var result = new FormalParameter (name, parameter_type, source_reference);
+			var result = new FormalParameter (name, variable_type, source_reference);
 			result.params_array = params_array;
 			result.direction = this.direction;
-			result.default_expression = this.default_expression;
+			result.initializer = this.initializer;
 			return result;
 		} else {
 			return new FormalParameter.with_ellipsis ();
@@ -231,37 +202,37 @@ public class Vala.FormalParameter : Symbol {
 		}
 		analyzer.current_symbol = parent_symbol;
 
-		if (parameter_type != null) {
-			parameter_type.check (analyzer);
+		if (variable_type != null) {
+			variable_type.check (analyzer);
 		}
 
 		if (!ellipsis) {
-			parameter_type.check (analyzer);
+			variable_type.check (analyzer);
 			
-			if (params_array && !(parameter_type is ArrayType)) {
+			if (params_array && !(variable_type is ArrayType)) {
 				error = true;
 				Report.error (source_reference, "parameter array expected");
 				return false;
 			}
 
-			if (default_expression != null) {
-				default_expression.check (analyzer);
+			if (initializer != null) {
+				initializer.check (analyzer);
 			}
 		}
 
-		if (default_expression != null) {
-			if (default_expression is NullLiteral
-			    && !parameter_type.nullable
+		if (initializer != null) {
+			if (initializer is NullLiteral
+			    && !variable_type.nullable
 			    && direction != ParameterDirection.OUT) {
-				Report.warning (source_reference, "`null' incompatible with parameter type `%s`".printf (parameter_type.to_string ()));
+				Report.warning (source_reference, "`null' incompatible with parameter type `%s`".printf (variable_type.to_string ()));
 			}
 		}
 
 		if (!ellipsis) {
 			// check whether parameter type is at least as accessible as the method
-			if (!analyzer.is_type_accessible (this, parameter_type)) {
+			if (!analyzer.is_type_accessible (this, variable_type)) {
 				error = true;
-				Report.error (source_reference, "parameter type `%s` is less accessible than method `%s`".printf (parameter_type.to_string (), parent_symbol.get_full_name ()));
+				Report.error (source_reference, "parameter type `%s` is less accessible than method `%s`".printf (variable_type.to_string (), parent_symbol.get_full_name ()));
 			}
 		}
 
diff --git a/vala/valagenieparser.vala b/vala/valagenieparser.vala
index 50e6e7d37..20e2263cc 100644
--- a/vala/valagenieparser.vala
+++ b/vala/valagenieparser.vala
@@ -3041,7 +3041,7 @@ public class Vala.Genie.Parser : CodeVisitor {
 		}
 
 		if (accept (TokenType.ASSIGN)) {
-			prop.default_expression = parse_expression ();
+			prop.initializer = parse_expression ();
 		}
 
 
@@ -3123,8 +3123,8 @@ public class Vala.Genie.Parser : CodeVisitor {
 
 			if (needs_var) {
 				/* automatic property accessor body generation */
-				var field_type = prop.property_type.copy ();
-				prop.field = new Field ("_%s".printf (prop.name), field_type, prop.default_expression, prop.source_reference);
+				var variable_type = prop.property_type.copy ();
+				prop.field = new Field ("_%s".printf (prop.name), variable_type, prop.initializer, prop.source_reference);
 				prop.field.access = SymbolAccessibility.PRIVATE;
 				prop.field.binding = prop.binding;
 			}
@@ -3578,7 +3578,7 @@ public class Vala.Genie.Parser : CodeVisitor {
 		param.direction = direction;
 		param.params_array = params_array;
 		if (accept (TokenType.ASSIGN)) {
-			param.default_expression = parse_expression ();
+			param.initializer = parse_expression ();
 		}
 		return param;
 	}
diff --git a/vala/valagirparser.vala b/vala/valagirparser.vala
index 67f8437f5..47268583f 100644
--- a/vala/valagirparser.vala
+++ b/vala/valagirparser.vala
@@ -1124,7 +1124,7 @@ public class Vala.GirParser : CodeVisitor {
 					}
 					info.param.carray_length_parameter_position = parameters[info.array_length_idx-add].vala_idx;
 				}
-				if (info.param.parameter_type is ArrayType && info.array_length_idx == -1) {
+				if (info.param.variable_type is ArrayType && info.array_length_idx == -1) {
 					info.param.no_array_length = true;
 				}
 
diff --git a/vala/valainitializerlist.vala b/vala/valainitializerlist.vala
index 927f5cee2..c415ff218 100644
--- a/vala/valainitializerlist.vala
+++ b/vala/valainitializerlist.vala
@@ -159,7 +159,7 @@ public class Vala.InitializerList : Expression {
 					}
 				}
 
-				e.target_type = field.field_type.copy ();
+				e.target_type = field.variable_type.copy ();
 				if (!target_type.value_owned) {
 					e.target_type.value_owned = false;
 				}
diff --git a/vala/valalambdaexpression.vala b/vala/valalambdaexpression.vala
index 2c5d0a69c..34130d47b 100644
--- a/vala/valalambdaexpression.vala
+++ b/vala/valalambdaexpression.vala
@@ -187,7 +187,7 @@ public class Vala.LambdaExpression : Expression {
 			}
 
 			string lambda_param = lambda_param_it.get ();
-			var param_type = cb_param.parameter_type.get_actual_type (target_type, null, this);
+			var param_type = cb_param.variable_type.get_actual_type (target_type, null, this);
 			var param = new FormalParameter (lambda_param, param_type);
 			method.add_parameter (param);
 		}
diff --git a/vala/valalocalvariable.vala b/vala/valalocalvariable.vala
index f252ceeac..5ef1107fb 100644
--- a/vala/valalocalvariable.vala
+++ b/vala/valalocalvariable.vala
@@ -25,35 +25,7 @@ using GLib;
 /**
  * Represents a local variable declaration in the source code.
  */
-public class Vala.LocalVariable : Symbol {
-	/**
-	 * The optional initializer expression.
-	 */
-	public Expression? initializer {
-		get {
-			return _initializer;
-		}
-		set {
-			_initializer = value;
-			if (_initializer != null) {
-				_initializer.parent_node = this;
-			}
-		}
-	}
-	
-	/**
-	 * The variable type.
-	 */
-	public DataType? variable_type {
-		get { return _variable_type; }
-		set {
-			_variable_type = value;
-			if (_variable_type != null) {
-				_variable_type.parent_node = this;
-			}
-		}
-	}
-
+public class Vala.LocalVariable : Variable {
 	public bool is_result { get; set; }
 
 	/**
@@ -65,9 +37,6 @@ public class Vala.LocalVariable : Symbol {
 
 	public bool no_init { get; set; }
 
-	private Expression? _initializer;
-	private DataType? _variable_type;
-
 	/**
 	 * Creates a new local variable.
 	 *
@@ -77,9 +46,7 @@ public class Vala.LocalVariable : Symbol {
 	 * @return       newly created variable declarator
 	 */
 	public LocalVariable (DataType? variable_type, string name, Expression? initializer = null, SourceReference? source_reference = null) {
-		base (name, source_reference);
-		this.variable_type = variable_type;
-		this.initializer = initializer;
+		base (variable_type, name, initializer, source_reference);
 	}
 	
 	public override void accept (CodeVisitor visitor) {
diff --git a/vala/valamemberaccess.vala b/vala/valamemberaccess.vala
index b6325f222..bc9717ff0 100644
--- a/vala/valamemberaccess.vala
+++ b/vala/valamemberaccess.vala
@@ -521,7 +521,7 @@ public class Vala.MemberAccess : Expression {
 
 			// do not allow access to fields of generic types
 			// if instance type does not specify type arguments
-			if (f.field_type is GenericType) {
+			if (f.variable_type is GenericType) {
 				generics = true;
 			}
 		} else if (member is Method) {
@@ -574,7 +574,7 @@ public class Vala.MemberAccess : Expression {
 			// do not allow access to methods using generic type parameters
 			// if instance type does not specify type arguments
 			foreach (var param in m.get_parameters ()) {
-				var generic_type = param.parameter_type as GenericType;
+				var generic_type = param.variable_type as GenericType;
 				if (generic_type != null && generic_type.type_parameter.parent_symbol is TypeSymbol) {
 					generics = true;
 					break;
@@ -724,7 +724,7 @@ public class Vala.MemberAccess : Expression {
 			// implicit this access
 			if (instance && inner == null) {
 				inner = new MemberAccess (null, "this", source_reference);
-				inner.value_type = this_parameter.parameter_type.copy ();
+				inner.value_type = this_parameter.variable_type.copy ();
 				inner.symbol_reference = this_parameter;
 			}
 
diff --git a/vala/valamethod.vala b/vala/valamethod.vala
index 8b361066d..5119c03c7 100644
--- a/vala/valamethod.vala
+++ b/vala/valamethod.vala
@@ -545,8 +545,8 @@ public class Vala.Method : Symbol {
 				return false;
 			}
 			
-			actual_base_type = base_param.parameter_type.get_actual_type (object_type, null, this);
-			if (!actual_base_type.equals (method_params_it.get ().parameter_type)) {
+			actual_base_type = base_param.variable_type.get_actual_type (object_type, null, this);
+			if (!actual_base_type.equals (method_params_it.get ().variable_type)) {
 				invalid_match = "incompatible type of parameter %d".printf (param_index);
 				return false;
 			}
@@ -996,12 +996,12 @@ public class Vala.Method : Symbol {
 			return false;
 		}
 		
-		if (!(param.parameter_type is ArrayType)) {
+		if (!(param.variable_type is ArrayType)) {
 			// parameter must be an array
 			return false;
 		}
 		
-		var array_type = (ArrayType) param.parameter_type;
+		var array_type = (ArrayType) param.variable_type;
 		if (array_type.element_type.data_type != analyzer.string_type.data_type) {
 			// parameter must be an array of strings
 			return false;
@@ -1013,7 +1013,7 @@ public class Vala.Method : Symbol {
 	public int get_required_arguments () {
 		int n = 0;
 		foreach (var param in parameters) {
-			if (param.default_expression != null || param.ellipsis) {
+			if (param.initializer != null || param.ellipsis) {
 				// optional argument
 				break;
 			}
@@ -1056,7 +1056,7 @@ public class Vala.Method : Symbol {
 		callback_type.is_called_once = true;
 
 		var callback_param = new FormalParameter ("_callback_", callback_type);
-		callback_param.default_expression = new NullLiteral (source_reference);
+		callback_param.initializer = new NullLiteral (source_reference);
 		callback_param.cparameter_position = -1;
 		callback_param.cdelegate_target_parameter_position = -0.9;
 
diff --git a/vala/valamethodcall.vala b/vala/valamethodcall.vala
index 4da68f7e8..af41a66a7 100644
--- a/vala/valamethodcall.vala
+++ b/vala/valamethodcall.vala
@@ -323,7 +323,7 @@ public class Vala.MethodCall : Expression {
 			}
 
 			if (param.params_array) {
-				var array_type = (ArrayType) param.parameter_type;
+				var array_type = (ArrayType) param.variable_type;
 				while (arg_it.next ()) {
 					Expression arg = arg_it.get ();
 
@@ -338,7 +338,7 @@ public class Vala.MethodCall : Expression {
 				Expression arg = arg_it.get ();
 
 				/* store expected type for callback parameters */
-				arg.formal_target_type = param.parameter_type;
+				arg.formal_target_type = param.variable_type;
 				arg.target_type = arg.formal_target_type.get_actual_type (target_object_type, call as MemberAccess, this);
 
 				last_arg = arg;
@@ -587,7 +587,7 @@ public class Vala.MethodCall : Expression {
 							if (arg_it.next ()) {
 								Expression arg = arg_it.get ();
 
-								var generic_type = param.parameter_type as GenericType;
+								var generic_type = param.variable_type as GenericType;
 								if (generic_type != null && generic_type.type_parameter == type_param) {
 									type_arg = arg.value_type.copy ();
 									type_arg.value_owned = true;
diff --git a/vala/valaobjectcreationexpression.vala b/vala/valaobjectcreationexpression.vala
index 8e334fe47..1a3ecc79b 100644
--- a/vala/valaobjectcreationexpression.vala
+++ b/vala/valaobjectcreationexpression.vala
@@ -333,7 +333,7 @@ public class Vala.ObjectCreationExpression : Expression {
 					Expression arg = arg_it.get ();
 
 					/* store expected type for callback parameters */
-					arg.formal_target_type = param.parameter_type;
+					arg.formal_target_type = param.variable_type;
 					arg.target_type = arg.formal_target_type.get_actual_type (value_type, null, this);
 				}
 			}
diff --git a/vala/valaparser.vala b/vala/valaparser.vala
index 2acbceef4..9161da2f7 100644
--- a/vala/valaparser.vala
+++ b/vala/valaparser.vala
@@ -2739,11 +2739,11 @@ public class Vala.Parser : CodeVisitor {
 		expect (TokenType.OPEN_BRACE);
 		while (current () != TokenType.CLOSE_BRACE) {
 			if (accept (TokenType.DEFAULT)) {
-				if (prop.default_expression != null) {
+				if (prop.initializer != null) {
 					throw new ParseError.SYNTAX (get_error ("property default value already defined"));
 				}
 				expect (TokenType.ASSIGN);
-				prop.default_expression = parse_expression ();
+				prop.initializer = parse_expression ();
 				expect (TokenType.SEMICOLON);
 			} else {
 				var accessor_begin = get_location ();
@@ -2812,12 +2812,12 @@ public class Vala.Parser : CodeVisitor {
 
 			if (empty_get && empty_set) {
 				/* automatic property accessor body generation */
-				var field_type = prop.property_type.copy ();
-				prop.field = new Field ("_%s".printf (prop.name), field_type, prop.default_expression, prop.source_reference);
+				var variable_type = prop.property_type.copy ();
+				prop.field = new Field ("_%s".printf (prop.name), variable_type, prop.initializer, prop.source_reference);
 				prop.field.access = SymbolAccessibility.PRIVATE;
 				prop.field.binding = prop.binding;
-			} else if (prop.default_expression != null) {
-				Report.error (prop.default_expression.source_reference, "only automatic properties can have default values");
+			} else if (prop.initializer != null) {
+				Report.error (prop.initializer.source_reference, "only automatic properties can have default values");
 			}
 		}
 
@@ -3279,7 +3279,7 @@ public class Vala.Parser : CodeVisitor {
 		param.direction = direction;
 		param.params_array = params_array;
 		if (accept (TokenType.ASSIGN)) {
-			param.default_expression = parse_expression ();
+			param.initializer = parse_expression ();
 		}
 		return param;
 	}
diff --git a/vala/valaproperty.vala b/vala/valaproperty.vala
index 4f31ae284..7621099c7 100644
--- a/vala/valaproperty.vala
+++ b/vala/valaproperty.vala
@@ -144,7 +144,7 @@ public class Vala.Property : Symbol, Lockable {
 	/**
 	 * Specifies the default value of this property.
 	 */
-	public Expression default_expression { get; set; }
+	public Expression initializer { get; set; }
 
 	public bool no_array_length { get; set; }
 
@@ -220,8 +220,8 @@ public class Vala.Property : Symbol, Lockable {
 			set_accessor.accept (visitor);
 		}
 
-		if (default_expression != null) {
-			default_expression.accept (visitor);
+		if (initializer != null) {
+			initializer.accept (visitor);
 		}
 	}
 
@@ -487,8 +487,8 @@ public class Vala.Property : Symbol, Lockable {
 			set_accessor.check (analyzer);
 		}
 
-		if (default_expression != null) {
-			default_expression.check (analyzer);
+		if (initializer != null) {
+			initializer.check (analyzer);
 		}
 
 		// check whether property type is at least as accessible as the property
@@ -513,9 +513,9 @@ public class Vala.Property : Symbol, Lockable {
 			}
 		}
 
-		if (default_expression != null && !default_expression.error && default_expression.value_type != null && !(default_expression.value_type.compatible (property_type))) {
+		if (initializer != null && !initializer.error && initializer.value_type != null && !(initializer.value_type.compatible (property_type))) {
 			error = true;
-			Report.error (default_expression.source_reference, "Expected initializer of type `%s' but got `%s'".printf (property_type.to_string (), default_expression.value_type.to_string ()));
+			Report.error (initializer.source_reference, "Expected initializer of type `%s' but got `%s'".printf (property_type.to_string (), initializer.value_type.to_string ()));
 		}
 
 		analyzer.current_source_file = old_source_file;
diff --git a/vala/valasemanticanalyzer.vala b/vala/valasemanticanalyzer.vala
index 4a6ab8765..8226aed18 100644
--- a/vala/valasemanticanalyzer.vala
+++ b/vala/valasemanticanalyzer.vala
@@ -256,7 +256,7 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
 	public DataType? get_value_type_for_symbol (Symbol sym, bool lvalue) {
 		if (sym is Field) {
 			var f = (Field) sym;
-			var type = f.field_type.copy ();
+			var type = f.variable_type.copy ();
 			if (!lvalue) {
 				type.value_owned = false;
 			}
@@ -279,7 +279,7 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
 			}
 		} else if (sym is FormalParameter) {
 			var p = (FormalParameter) sym;
-			var type = p.parameter_type.copy ();
+			var type = p.variable_type.copy ();
 			if (!lvalue) {
 				type.value_owned = false;
 			}
@@ -417,7 +417,7 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
 			}
 
 			if (arg_it == null || !arg_it.next ()) {
-				if (param.default_expression == null) {
+				if (param.initializer == null) {
 					expr.error = true;
 					Report.error (expr.source_reference, "Too few arguments, method `%s' does not take %d arguments".printf (mtype.to_string (), args.size));
 					return false;
@@ -425,9 +425,9 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
 					var invocation_expr = expr as MethodCall;
 					var object_creation_expr = expr as ObjectCreationExpression;
 					if (invocation_expr != null) {
-						invocation_expr.add_argument (param.default_expression);
+						invocation_expr.add_argument (param.initializer);
 					} else if (object_creation_expr != null) {
-						object_creation_expr.add_argument (param.default_expression);
+						object_creation_expr.add_argument (param.initializer);
 					} else {
 						assert_not_reached ();
 					}
@@ -772,7 +772,7 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
 		DataType member_type = null;
 		if (init.symbol_reference is Field) {
 			var f = (Field) init.symbol_reference;
-			member_type = f.field_type;
+			member_type = f.variable_type;
 		} else if (init.symbol_reference is Property) {
 			var prop = (Property) init.symbol_reference;
 			member_type = prop.property_type;
diff --git a/vala/valasignal.vala b/vala/valasignal.vala
index 87d2efe29..926c75fbb 100644
--- a/vala/valasignal.vala
+++ b/vala/valasignal.vala
@@ -139,7 +139,7 @@ public class Vala.Signal : Symbol, Lockable {
 
 		foreach (FormalParameter param in parameters) {
 			var actual_param = param.copy ();
-			actual_param.parameter_type = actual_param.parameter_type.get_actual_type (sender_type, null, node_reference);
+			actual_param.variable_type = actual_param.variable_type.get_actual_type (sender_type, null, node_reference);
 			generated_delegate.add_parameter (actual_param);
 		}
 
diff --git a/vala/valastruct.vala b/vala/valastruct.vala
index 180c67e65..c05618e3d 100644
--- a/vala/valastruct.vala
+++ b/vala/valastruct.vala
@@ -745,7 +745,7 @@ public class Vala.Struct : TypeSymbol {
 
 		foreach (Field f in fields) {
 			if (f.binding == MemberBinding.INSTANCE
-			    && f.field_type.is_disposable ()) {
+			    && f.variable_type.is_disposable ()) {
 				return true;
 			}
 		}
@@ -761,7 +761,7 @@ public class Vala.Struct : TypeSymbol {
 				return true;
 			}
 			foreach (Field f in st.fields) {
-				if (f.binding == MemberBinding.INSTANCE && is_recursive_value_type (f.field_type)) {
+				if (f.binding == MemberBinding.INSTANCE && is_recursive_value_type (f.variable_type)) {
 					return true;
 				}
 			}
@@ -803,7 +803,7 @@ public class Vala.Struct : TypeSymbol {
 		foreach (Field f in fields) {
 			f.check (analyzer);
 
-			if (f.binding == MemberBinding.INSTANCE && is_recursive_value_type (f.field_type)) {
+			if (f.binding == MemberBinding.INSTANCE && is_recursive_value_type (f.variable_type)) {
 				error = true;
 				Report.error (f.source_reference, "Recursive value types are not allowed");
 				return false;
diff --git a/vala/valavariable.vala b/vala/valavariable.vala
new file mode 100644
index 000000000..9337751e1
--- /dev/null
+++ b/vala/valavariable.vala
@@ -0,0 +1,60 @@
+/* valavariable.vala
+ *
+ * Copyright (C) 2010  Jürg Billeter
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+ *
+ * Author:
+ * 	Jürg Billeter <j@bitron.ch>
+ */
+
+public class Vala.Variable : Symbol {
+	/**
+	 * The optional initializer expression.
+	 */
+	public Expression? initializer {
+		get {
+			return _initializer;
+		}
+		set {
+			_initializer = value;
+			if (_initializer != null) {
+				_initializer.parent_node = this;
+			}
+		}
+	}
+	
+	/**
+	 * The variable type.
+	 */
+	public DataType? variable_type {
+		get { return _variable_type; }
+		set {
+			_variable_type = value;
+			if (_variable_type != null) {
+				_variable_type.parent_node = this;
+			}
+		}
+	}
+
+	Expression? _initializer;
+	DataType? _variable_type;
+
+	public Variable (DataType? variable_type, string? name, Expression? initializer = null, SourceReference? source_reference = null, Comment? comment = null) {
+		base (name, source_reference, comment);
+		this.variable_type = variable_type;
+		this.initializer = initializer;
+	}
+}
diff --git a/vapigen/valagidlparser.vala b/vapigen/valagidlparser.vala
index 985665e20..8f28562ce 100644
--- a/vapigen/valagidlparser.vala
+++ b/vapigen/valagidlparser.vala
@@ -367,7 +367,7 @@ public class Vala.GIdlParser : CodeVisitor {
 						} else if (nv[0] == "is_array") {
 							if (eval (nv[1]) == "1") {
 								param_type = new ArrayType (param_type, 1, param_type.source_reference);
-								p.parameter_type = param_type;
+								p.variable_type = param_type;
 								if (!out_requested) {
 									p.direction = ParameterDirection.IN;
 								}
@@ -380,7 +380,7 @@ public class Vala.GIdlParser : CodeVisitor {
 								if (!array_requested && param_type is ArrayType) {
 									var array_type = (ArrayType) param_type;
 									param_type = array_type.element_type;
-									p.parameter_type = param_type;
+									p.variable_type = param_type;
 								}
 							}
 						} else if (nv[0] == "is_ref") {
@@ -389,7 +389,7 @@ public class Vala.GIdlParser : CodeVisitor {
 								if (!array_requested && param_type is ArrayType) {
 									var array_type = (ArrayType) param_type;
 									param_type = array_type.element_type;
-									p.parameter_type = param_type;
+									p.variable_type = param_type;
 								}
 							}
 						} else if (nv[0] == "takes_ownership") {
@@ -416,7 +416,7 @@ public class Vala.GIdlParser : CodeVisitor {
 							} else {
 								// Overwrite old param_type, so "type_name" must be before any
 								// other param type modifying metadata
-								p.parameter_type = param_type = new UnresolvedType.from_symbol (sym, return_type.source_reference);
+								p.variable_type = param_type = new UnresolvedType.from_symbol (sym, return_type.source_reference);
 							}
 						}
 					}
@@ -1851,7 +1851,7 @@ public class Vala.GIdlParser : CodeVisitor {
 					if (nv[0] == "is_array") {
 						if (eval (nv[1]) == "1") {
 							param_type = new ArrayType (param_type, 1, param_type.source_reference);
-							p.parameter_type = param_type;
+							p.variable_type = param_type;
 							if (!out_requested) {
 								p.direction = ParameterDirection.IN;
 							}
@@ -1864,7 +1864,7 @@ public class Vala.GIdlParser : CodeVisitor {
 							if (!array_requested && param_type is ArrayType) {
 								var array_type = (ArrayType) param_type;
 								param_type = array_type.element_type;
-								p.parameter_type = param_type;
+								p.variable_type = param_type;
 							}
 						}
 					} else if (nv[0] == "is_ref") {
@@ -1873,7 +1873,7 @@ public class Vala.GIdlParser : CodeVisitor {
 							if (!array_requested && param_type is ArrayType) {
 								var array_type = (ArrayType) param_type;
 								param_type = array_type.element_type;
-								p.parameter_type = param_type;
+								p.variable_type = param_type;
 							}
 						}
 					} else if (nv[0] == "nullable") {
@@ -1924,7 +1924,7 @@ public class Vala.GIdlParser : CodeVisitor {
 						} else {
 							// Overwrite old param_type, so "type_name" must be before any
 							// other param type modifying metadata
-							p.parameter_type = param_type = new UnresolvedType.from_symbol (sym, return_type.source_reference);
+							p.variable_type = param_type = new UnresolvedType.from_symbol (sym, return_type.source_reference);
 						}
 					} else if (nv[0] == "ctype") {
 						p.ctype = eval (nv[1]);
@@ -1936,30 +1936,30 @@ public class Vala.GIdlParser : CodeVisitor {
 					} else if (nv[0] == "default_value") {
 						var val = eval (nv[1]);
 						if (val == "null") {
-							p.default_expression = new NullLiteral (param_type.source_reference);
+							p.initializer = new NullLiteral (param_type.source_reference);
 						} else if (val == "true") {
-							p.default_expression = new BooleanLiteral (true, param_type.source_reference);
+							p.initializer = new BooleanLiteral (true, param_type.source_reference);
 						} else if (val == "false") {
-							p.default_expression = new BooleanLiteral (false, param_type.source_reference);
+							p.initializer = new BooleanLiteral (false, param_type.source_reference);
 						} else if (val == "") {
-							p.default_expression = new StringLiteral ("\"\"", param_type.source_reference);
+							p.initializer = new StringLiteral ("\"\"", param_type.source_reference);
 						} else {
 							unowned string endptr;
 							unowned string val_end = val.offset (val.len ());
 
 							val.to_long (out endptr);
 							if ((long)endptr == (long)val_end) {
-								p.default_expression = new IntegerLiteral (val, param_type.source_reference);
+								p.initializer = new IntegerLiteral (val, param_type.source_reference);
 							} else {
 								val.to_double (out endptr);
 								if ((long)endptr == (long)val_end) {
-									p.default_expression = new RealLiteral (val, param_type.source_reference);
+									p.initializer = new RealLiteral (val, param_type.source_reference);
 								} else {
 									if (val.has_prefix ("\"") && val.has_suffix ("\"")) {
-										p.default_expression = new StringLiteral (val, param_type.source_reference);
+										p.initializer = new StringLiteral (val, param_type.source_reference);
 									} else {
 										foreach (var member in val.split (".")) {
-											p.default_expression = new MemberAccess (p.default_expression, member, param_type.source_reference);
+											p.initializer = new MemberAccess (p.initializer, member, param_type.source_reference);
 										}
 									}
 								}
@@ -1973,7 +1973,7 @@ public class Vala.GIdlParser : CodeVisitor {
 				if (!(last_param_type is ArrayType)) {
 					// last_param is array, p is array length
 					last_param_type = new ArrayType (last_param_type, 1, last_param_type.source_reference);
-					last_param.parameter_type = last_param_type;
+					last_param.variable_type = last_param_type;
 					last_param.direction = ParameterDirection.IN;
 				}
 
@@ -2479,7 +2479,7 @@ public class Vala.GIdlParser : CodeVisitor {
 					if (nv[0] == "is_array") {
 						if (eval (nv[1]) == "1") {
 							param_type = new ArrayType (param_type, 1, param_type.source_reference);
-							p.parameter_type = param_type;
+							p.variable_type = param_type;
 							p.direction = ParameterDirection.IN;
 						}
 					} else if (nv[0] == "is_out") {
@@ -2501,13 +2501,13 @@ public class Vala.GIdlParser : CodeVisitor {
 					} else if (nv[0] == "type_name") {
 						if (!(param_type is UnresolvedType)) {
 							param_type = new UnresolvedType ();
-							p.parameter_type = param_type;
+							p.variable_type = param_type;
 						}
 						((UnresolvedType) param_type).unresolved_symbol = new UnresolvedSymbol (null, eval (nv[1]));
 					} else if (nv[0] == "type_arguments") {
 						var type_args = eval (nv[1]).split (",");
 						foreach (string type_arg in type_args) {
-							p.parameter_type.add_type_argument (get_type_from_string (type_arg));
+							p.variable_type.add_type_argument (get_type_from_string (type_arg));
 						}
 					} else if (nv[0] == "namespace_name") {
 						ns_name = eval (nv[1]);