Rename FormalParameter.type_reference to FormalParameter.parameter_type

2008-05-13  Juerg Billeter  <j@bitron.ch>

	* vala/valadelegate.vala:
	* vala/valaformalparameter.vala:
	* vala/valainterfacewriter.vala:
	* vala/valamemorymanager.vala:
	* vala/valamethod.vala:
	* vala/valanullchecker.vala:
	* vala/valasemanticanalyzer.vala:
	* vala/valasourcefile.vala:
	* gobject/valaccodeassignmentbinding.vala:
	* gobject/valaccodeclassbinding.vala:
	* gobject/valaccodedynamicmethodbinding.vala:
	* gobject/valaccodedynamicsignalbinding.vala:
	* gobject/valaccodeelementaccessbinding.vala:
	* gobject/valaccodegenerator.vala:
	* gobject/valaccodegeneratorsignal.vala:
	* gobject/valaccodeinvocationexpressionbinding.vala:
	* gobject/valaccodememberaccessbinding.vala:
	* gobject/valaccodemethodbinding.vala:
	* gobject/valaccodetypesymbolbinding.vala:
	* gobject/valagidlwriter.vala:

	Rename FormalParameter.type_reference to
	FormalParameter.parameter_type

svn path=/trunk/; revision=1388

diff --git a/ChangeLog b/ChangeLog
index 0428ba751d4baedd0e0c4fbf94731ac660c3d9e5..55f87efad2500c6414ae8f063eb6032f1f697f82 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,29 @@
+2008-05-13  Jürg Billeter  <j@bitron.ch>
+
+       * vala/valadelegate.vala:
+       * vala/valaformalparameter.vala:
+       * vala/valainterfacewriter.vala:
+       * vala/valamemorymanager.vala:
+       * vala/valamethod.vala:
+       * vala/valanullchecker.vala:
+       * vala/valasemanticanalyzer.vala:
+       * vala/valasourcefile.vala:
+       * gobject/valaccodeassignmentbinding.vala:
+       * gobject/valaccodeclassbinding.vala:
+       * gobject/valaccodedynamicmethodbinding.vala:
+       * gobject/valaccodedynamicsignalbinding.vala:
+       * gobject/valaccodeelementaccessbinding.vala:
+       * gobject/valaccodegenerator.vala:
+       * gobject/valaccodegeneratorsignal.vala:
+       * gobject/valaccodeinvocationexpressionbinding.vala:
+       * gobject/valaccodememberaccessbinding.vala:
+       * gobject/valaccodemethodbinding.vala:
+       * gobject/valaccodetypesymbolbinding.vala:
+       * gobject/valagidlwriter.vala:
+
+       Rename FormalParameter.type_reference to
+       FormalParameter.parameter_type
+
 2008-05-13  Jürg Billeter  <j@bitron.ch>
 
        * vala/valaarraytype.vala:

diff --git a/gobject/valaccodeassignmentbinding.vala b/gobject/valaccodeassignmentbinding.vala
index c132acafb97c5058c8098d661b5cf43d3beb1baf..cfcd6c8b744eb5a99e2852c03c4985483f471b4c 100644 (file)
--- a/gobject/valaccodeassignmentbinding.vala
+++ b/gobject/valaccodeassignmentbinding.vala
@@ -349,8 +349,8 @@ public class Vala.CCodeAssignmentBinding : CCodeExpressionBinding {
                        set_params_it.next ();
                        var set_param = set_params_it.get ();
 
-                       if (set_param.type_reference.type_parameter != null) {
-                               var index_type = SemanticAnalyzer.get_actual_type (expr.container.value_type, set_method, set_param.type_reference, assignment);
+                       if (set_param.parameter_type.type_parameter != null) {
+                               var index_type = SemanticAnalyzer.get_actual_type (expr.container.value_type, set_method, set_param.parameter_type, assignment);
                                cindex = codegen.convert_to_generic_pointer (cindex, index_type);
                        }
 

diff --git a/gobject/valaccodeclassbinding.vala b/gobject/valaccodeclassbinding.vala
index beb9ee64fcc147904a82ba56125df2784be75742..1830636a16db2c77de7753ff86ba5d4d3752aae8 100644 (file)
--- a/gobject/valaccodeclassbinding.vala
+++ b/gobject/valaccodeclassbinding.vala
@@ -821,7 +821,7 @@ public class Vala.CCodeClassBinding : CCodeTypesymbolBinding {
                                        Report.error (param.source_reference, "unsupported parameter direction for D-Bus method");
                                }
 
-                               blob.append (param.type_reference.get_type_signature ());
+                               blob.append (param.parameter_type.get_type_signature ());
                                blob.append ("\\0");
                                start++;
                        }

diff --git a/gobject/valaccodedynamicmethodbinding.vala b/gobject/valaccodedynamicmethodbinding.vala
index edf7809d6bceceb5111b53f3bba42549298461c8..aff92b17b0e2447330ddd6239ab2f934513e88a9 100644 (file)
--- a/gobject/valaccodedynamicmethodbinding.vala
+++ b/gobject/valaccodedynamicmethodbinding.vala
@@ -131,8 +131,8 @@ public class Vala.CCodeDynamicMethodBinding : CCodeMethodBinding {
                                        // error parameter
                                        break;
                                }
-                               if (param.type_reference is ArrayType && ((ArrayType) param.type_reference).element_type.data_type != codegen.string_type.data_type) {
-                                       var array_type = (ArrayType) param.type_reference;
+                               if (param.parameter_type is ArrayType && ((ArrayType) param.parameter_type).element_type.data_type != codegen.string_type.data_type) {
+                                       var array_type = (ArrayType) param.parameter_type;
                                        var cdecl = new CCodeDeclaration ("GArray*");
                                        cdecl.add_declarator (new CCodeVariableDeclarator (param.name));
                                        cb_fun.block.add_statement (cdecl);
@@ -141,19 +141,19 @@ public class Vala.CCodeDynamicMethodBinding : CCodeMethodBinding {
                                        creply_call.add_argument (new CCodeMemberAccess.pointer (new CCodeIdentifier (param.name), "data"));
                                        creply_call.add_argument (new CCodeMemberAccess.pointer (new CCodeIdentifier (param.name), "len"));
                                } else {
-                                       var cdecl = new CCodeDeclaration (param.type_reference.get_cname ());
+                                       var cdecl = new CCodeDeclaration (param.parameter_type.get_cname ());
                                        cdecl.add_declarator (new CCodeVariableDeclarator (param.name));
                                        cb_fun.block.add_statement (cdecl);
-                                       if (param.type_reference is ArrayType && ((ArrayType) param.type_reference).element_type.data_type == codegen.string_type.data_type) {
+                                       if (param.parameter_type is ArrayType && ((ArrayType) param.parameter_type).element_type.data_type == codegen.string_type.data_type) {
                                                // special case string array
                                                cend_call.add_argument (new CCodeIdentifier ("G_TYPE_STRV"));
                                        } else {
-                                               cend_call.add_argument (new CCodeIdentifier (param.type_reference.data_type.get_type_id ()));
+                                               cend_call.add_argument (new CCodeIdentifier (param.parameter_type.data_type.get_type_id ()));
                                        }
                                        cend_call.add_argument (new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (param.name)));
                                        creply_call.add_argument (new CCodeIdentifier (param.name));
 
-                                       if (param.type_reference is ArrayType && ((ArrayType) param.type_reference).element_type.data_type == codegen.string_type.data_type) {
+                                       if (param.parameter_type is ArrayType && ((ArrayType) param.parameter_type).element_type.data_type == codegen.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);
@@ -179,12 +179,12 @@ public class Vala.CCodeDynamicMethodBinding : CCodeMethodBinding {
                }
 
                foreach (FormalParameter param in method.get_parameters ()) {
-                       if (param.type_reference is MethodType) {
+                       if (param.parameter_type is MethodType) {
                                // callback parameter
                                break;
                        }
 
-                       ccall.add_argument (new CCodeIdentifier (param.type_reference.data_type.get_type_id ()));
+                       ccall.add_argument (new CCodeIdentifier (param.parameter_type.data_type.get_type_id ()));
                        ccall.add_argument (new CCodeIdentifier (param.name));
                }
 

diff --git a/gobject/valaccodedynamicsignalbinding.vala b/gobject/valaccodedynamicsignalbinding.vala
index ae7253d4feb5925e5e4361a5af0c598ba3cd0e08..0cf57968e02dddb02fc8bf79f132c77efc644a39 100644 (file)
--- a/gobject/valaccodedynamicsignalbinding.vala
+++ b/gobject/valaccodedynamicsignalbinding.vala
@@ -126,8 +126,8 @@ public class Vala.CCodeDynamicSignalBinding : CCodeBinding {
                                first = false;
                                continue;
                        }
-                       if (param.type_reference is ArrayType && ((ArrayType) param.type_reference).element_type.data_type != codegen.string_type.data_type) {
-                               var array_type = (ArrayType) param.type_reference;
+                       if (param.parameter_type is ArrayType && ((ArrayType) param.parameter_type).element_type.data_type != codegen.string_type.data_type) {
+                               var array_type = (ArrayType) param.parameter_type;
                                if (array_type.element_type.data_type.get_type_id () == null) {
                                        Report.error (param.source_reference, "unsupported parameter type for D-Bus signals");
                                        return;
@@ -139,13 +139,13 @@ public class Vala.CCodeDynamicSignalBinding : CCodeBinding {
                                register_call.add_argument (carray_type);
                                add_call.add_argument (carray_type);
                        } else {
-                               if (param.type_reference.get_type_id () == null) {
+                               if (param.parameter_type.get_type_id () == null) {
                                        Report.error (param.source_reference, "unsupported parameter type for D-Bus signals");
                                        return;
                                }
 
-                               register_call.add_argument (new CCodeIdentifier (param.type_reference.get_type_id ()));
-                               add_call.add_argument (new CCodeIdentifier (param.type_reference.get_type_id ()));
+                               register_call.add_argument (new CCodeIdentifier (param.parameter_type.get_type_id ()));
+                               add_call.add_argument (new CCodeIdentifier (param.parameter_type.get_type_id ()));
                        }
                }
                register_call.add_argument (new CCodeIdentifier ("G_TYPE_INVALID"));

diff --git a/gobject/valaccodeelementaccessbinding.vala b/gobject/valaccodeelementaccessbinding.vala
index e021fb38b2c75ed0ecf60419074c27ce29c535ec..94937c9552fcce3eef344b348a4033e5b8e9759c 100644 (file)
--- a/gobject/valaccodeelementaccessbinding.vala
+++ b/gobject/valaccodeelementaccessbinding.vala
@@ -77,8 +77,8 @@ public class Vala.CCodeElementAccessBinding : CCodeExpressionBinding {
                        get_params_it.next ();
                        var get_param = get_params_it.get ();
 
-                       if (get_param.type_reference.type_parameter != null) {
-                               var index_type = SemanticAnalyzer.get_actual_type (expr.container.value_type, get_method, get_param.type_reference, expr);
+                       if (get_param.parameter_type.type_parameter != null) {
+                               var index_type = SemanticAnalyzer.get_actual_type (expr.container.value_type, get_method, get_param.parameter_type, expr);
                                cindex = codegen.convert_to_generic_pointer (cindex, index_type);
                        }
 

diff --git a/gobject/valaccodegenerator.vala b/gobject/valaccodegenerator.vala
index bf47f9c3b1add7508dd030ff038175b5c3176d95..7271dba9f0576bbb7f861d106d9fa1a47f688d7a 100644 (file)
--- a/gobject/valaccodegenerator.vala
+++ b/gobject/valaccodegenerator.vala
@@ -244,7 +244,7 @@ public class Vala.CCodeGenerator : CodeGenerator {
                if (context.module_init_method != null) {
                        module_init_fragment = new CCodeFragment ();
                        foreach (FormalParameter parameter in context.module_init_method.get_parameters ()) {
-                               if (parameter.type_reference.data_type == type_module_type) {
+                               if (parameter.parameter_type.data_type == type_module_type) {
                                        in_plugin = true;
                                        module_init_param_name = parameter.name;
                                        break;
@@ -715,13 +715,13 @@ public class Vala.CCodeGenerator : CodeGenerator {
                p.accept_children (this);
 
                if (!p.ellipsis) {
-                       string ctypename = p.type_reference.get_cname ();
+                       string ctypename = p.parameter_type.get_cname ();
                        string cname = p.name;
 
                        // pass non-simple structs always by reference
-                       if (p.type_reference.data_type is Struct) {
-                               var st = (Struct) p.type_reference.data_type;
-                               if (!st.is_simple_type () && p.direction == ParameterDirection.IN && !p.type_reference.nullable) {
+                       if (p.parameter_type.data_type is Struct) {
+                               var st = (Struct) p.parameter_type.data_type;
+                               if (!st.is_simple_type () && p.direction == ParameterDirection.IN && !p.parameter_type.nullable) {
                                        ctypename += "*";
                                }
                        }
@@ -1081,10 +1081,10 @@ public class Vala.CCodeGenerator : CodeGenerator {
                if (b.parent_symbol is Method) {
                        var m = (Method) b.parent_symbol;
                        foreach (FormalParameter param in m.get_parameters ()) {
-                               if (param.type_reference.data_type != null && param.type_reference.data_type.is_reference_type () && param.type_reference.takes_ownership && param.direction == ParameterDirection.IN) {
+                               if (param.parameter_type.data_type != null && param.parameter_type.data_type.is_reference_type () && param.parameter_type.takes_ownership && param.direction == ParameterDirection.IN) {
                                        var ma = new MemberAccess.simple (param.name);
                                        ma.symbol_reference = param;
-                                       cblock.add_statement (new CCodeExpressionStatement (get_unref_expression (new CCodeIdentifier (get_variable_cname (param.name)), param.type_reference, ma)));
+                                       cblock.add_statement (new CCodeExpressionStatement (get_unref_expression (new CCodeIdentifier (get_variable_cname (param.name)), param.parameter_type, ma)));
                                }
                        }
                }
@@ -2139,10 +2139,10 @@ public class Vala.CCodeGenerator : CodeGenerator {
 
        private void append_param_free (Method m, CCodeFragment cfrag) {
                foreach (FormalParameter param in m.get_parameters ()) {
-                       if (param.type_reference.data_type != null && param.type_reference.data_type.is_reference_type () && param.type_reference.takes_ownership && param.direction == ParameterDirection.IN) {
+                       if (param.parameter_type.data_type != null && param.parameter_type.data_type.is_reference_type () && param.parameter_type.takes_ownership && param.direction == ParameterDirection.IN) {
                                var ma = new MemberAccess.simple (param.name);
                                ma.symbol_reference = param;
-                               cfrag.append (new CCodeExpressionStatement (get_unref_expression (new CCodeIdentifier (get_variable_cname (param.name)), param.type_reference, ma)));
+                               cfrag.append (new CCodeExpressionStatement (get_unref_expression (new CCodeIdentifier (get_variable_cname (param.name)), param.parameter_type, ma)));
                        }
                }
        }
@@ -2184,11 +2184,11 @@ public class Vala.CCodeGenerator : CodeGenerator {
                bool found = false;
 
                foreach (FormalParameter param in m.get_parameters ()) {
-                       if (param.type_reference.data_type != null && param.type_reference.data_type.is_reference_type () && param.type_reference.takes_ownership && param.direction == ParameterDirection.IN) {
+                       if (param.parameter_type.data_type != null && param.parameter_type.data_type.is_reference_type () && param.parameter_type.takes_ownership && param.direction == ParameterDirection.IN) {
                                found = true;
                                var ma = new MemberAccess.simple (param.name);
                                ma.symbol_reference = param;
-                               ccomma.append_expression (get_unref_expression (new CCodeIdentifier (get_variable_cname (param.name)), param.type_reference, ma));
+                               ccomma.append_expression (get_unref_expression (new CCodeIdentifier (get_variable_cname (param.name)), param.parameter_type, ma));
                        }
                }
 
@@ -2981,10 +2981,10 @@ public class Vala.CCodeGenerator : CodeGenerator {
                                        param = params_it.get ();
                                        ellipsis = param.ellipsis;
                                        if (!param.ellipsis) {
-                                               cexpr = get_implicit_cast_expression (cexpr, arg.value_type, param.type_reference);
+                                               cexpr = get_implicit_cast_expression (cexpr, arg.value_type, param.parameter_type);
 
                                                // pass non-simple struct instances always by reference
-                                               if (param.type_reference.data_type is Struct && !((Struct) param.type_reference.data_type).is_simple_type ()) {
+                                               if (param.parameter_type.data_type is Struct && !((Struct) param.parameter_type.data_type).is_simple_type ()) {
                                                        // we already use a reference for arguments of ref and out parameters
                                                        if (param.direction == ParameterDirection.IN) {
                                                                if (cexpr is CCodeIdentifier) {
@@ -3008,8 +3008,8 @@ public class Vala.CCodeGenerator : CodeGenerator {
                        
                                creation_call.add_argument (cexpr);
 
-                               if (param != null && param.type_reference is DelegateType) {
-                                       var deleg_type = (DelegateType) param.type_reference;
+                               if (param != null && param.parameter_type is DelegateType) {
+                                       var deleg_type = (DelegateType) param.parameter_type;
                                        var d = deleg_type.delegate_symbol;
                                        if (d.has_target) {
                                                creation_call.add_argument (get_delegate_target_cexpression (arg));
@@ -3448,8 +3448,8 @@ public class Vala.CCodeGenerator : CodeGenerator {
                        cparam_map.set (get_param_pos (param.cparameter_position), (CCodeFormalParameter) param.ccodenode);
 
                        // handle array parameters
-                       if (!param.no_array_length && param.type_reference is ArrayType) {
-                               var array_type = (ArrayType) param.type_reference;
+                       if (!param.no_array_length && param.parameter_type is ArrayType) {
+                               var array_type = (ArrayType) param.parameter_type;
                                
                                var length_ctype = "int";
                                if (param.direction != ParameterDirection.IN) {
@@ -3510,8 +3510,8 @@ public class Vala.CCodeGenerator : CodeGenerator {
                        carg_map.set (get_param_pos (param.cparameter_position), arg);
 
                        // handle array arguments
-                       if (!param.no_array_length && param.type_reference is ArrayType) {
-                               var array_type = (ArrayType) param.type_reference;
+                       if (!param.no_array_length && param.parameter_type is ArrayType) {
+                               var array_type = (ArrayType) param.parameter_type;
                                for (int dim = 1; dim <= array_type.rank; dim++) {
                                        CCodeExpression clength;
                                        if (d_params.get (i).no_array_length) {

diff --git a/gobject/valaccodegeneratorsignal.vala b/gobject/valaccodegeneratorsignal.vala
index 1ddefe268dd265e037a0e68fbd7827d1008acdea..ede2eeade9370a86f1ccde1350a5aac03429a229 100644 (file)
--- a/gobject/valaccodegeneratorsignal.vala
+++ b/gobject/valaccodegeneratorsignal.vala
@@ -46,7 +46,7 @@ public class Vala.CCodeGenerator {
                if (param.direction != ParameterDirection.IN) {
                        return ("POINTER");
                } else {
-                       return get_marshaller_type_name (param.type_reference);
+                       return get_marshaller_type_name (param.parameter_type);
                }
        }
        
@@ -106,7 +106,7 @@ public class Vala.CCodeGenerator {
                if (p.direction != ParameterDirection.IN) {
                        return "gpointer";
                } else {
-                       return get_value_type_name_from_type_reference (p.type_reference);
+                       return get_value_type_name_from_type_reference (p.parameter_type);
                }
        }
        
@@ -233,12 +233,12 @@ public class Vala.CCodeGenerator {
                i = 1;
                foreach (FormalParameter p in params) {
                        string get_value_function;
-                       if (p.type_reference is PointerType || p.type_reference.type_parameter != null || p.direction != ParameterDirection.IN) {
+                       if (p.parameter_type is PointerType || p.parameter_type.type_parameter != null || p.direction != ParameterDirection.IN) {
                                get_value_function = "g_value_get_pointer";
-                       } else if (p.type_reference is ErrorType) {
+                       } else if (p.parameter_type is ErrorType) {
                                get_value_function = "g_value_get_pointer";
                        } else {
-                               get_value_function = p.type_reference.data_type.get_get_value_function ();
+                               get_value_function = p.parameter_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 ())));

diff --git a/gobject/valaccodeinvocationexpressionbinding.vala b/gobject/valaccodeinvocationexpressionbinding.vala
index 12f411d866492e9318669300a5db087d18eeb9f4..04788fad8920d9649b27ad5e440cb3f96cd7f88f 100644 (file)
--- a/gobject/valaccodeinvocationexpressionbinding.vala
+++ b/gobject/valaccodeinvocationexpressionbinding.vala
@@ -176,30 +176,30 @@ public class Vala.CCodeInvocationExpressionBinding : CCodeExpressionBinding {
                                        // http://bugzilla.gnome.org/show_bug.cgi?id=519597
                                        bool multiple_cargs = false;
 
-                                       if (!param.no_array_length && param.type_reference is ArrayType) {
-                                               var array_type = (ArrayType) param.type_reference;
+                                       if (!param.no_array_length && param.parameter_type is ArrayType) {
+                                               var array_type = (ArrayType) param.parameter_type;
                                                for (int dim = 1; dim <= array_type.rank; dim++) {
                                                        carg_map.set (codegen.get_param_pos (param.carray_length_parameter_position + 0.01 * dim), codegen.get_array_length_cexpression (arg, dim));
                                                }
                                                multiple_cargs = true;
-                                       } else if (param.type_reference is DelegateType) {
-                                               var deleg_type = (DelegateType) param.type_reference;
+                                       } else if (param.parameter_type is DelegateType) {
+                                               var deleg_type = (DelegateType) param.parameter_type;
                                                var d = deleg_type.delegate_symbol;
                                                if (d.has_target) {
                                                        carg_map.set (codegen.get_param_pos (param.cdelegate_target_parameter_position), codegen.get_delegate_target_cexpression (arg));
                                                        multiple_cargs = true;
                                                }
-                                       } else if (param.type_reference is MethodType) {
+                                       } else if (param.parameter_type is MethodType) {
                                                carg_map.set (codegen.get_param_pos (param.cdelegate_target_parameter_position), codegen.get_delegate_target_cexpression (arg));
                                                multiple_cargs = true;
                                        }
                                        if (param.direction == ParameterDirection.IN) {
                                                // don't cast arguments passed by reference
-                                               cexpr = codegen.get_implicit_cast_expression (cexpr, arg.value_type, param.type_reference);
+                                               cexpr = codegen.get_implicit_cast_expression (cexpr, arg.value_type, param.parameter_type);
                                        }
 
                                        // pass non-simple struct instances always by reference
-                                       if (!(arg.value_type is NullType) && param.type_reference.data_type is Struct && !((Struct) param.type_reference.data_type).is_simple_type ()) {
+                                       if (!(arg.value_type is NullType) && param.parameter_type.data_type is Struct && !((Struct) param.parameter_type.data_type).is_simple_type ()) {
                                                // we already use a reference for arguments of ref and out parameters
                                                if (param.direction == ParameterDirection.IN) {
                                                        if (cexpr is CCodeIdentifier) {
@@ -239,7 +239,7 @@ public class Vala.CCodeInvocationExpressionBinding : CCodeExpressionBinding {
                                        }
 
                                        // unref old value for non-null non-weak out arguments
-                                       if (param.direction == ParameterDirection.OUT && param.type_reference.takes_ownership && !(arg.value_type is NullType)) {
+                                       if (param.direction == ParameterDirection.OUT && param.parameter_type.takes_ownership && !(arg.value_type is NullType)) {
                                                var unary = (UnaryExpression) arg;
 
                                                // (ret_tmp = call (&tmp), free (var1), var1 = tmp, ret_tmp)
@@ -301,9 +301,9 @@ public class Vala.CCodeInvocationExpressionBinding : CCodeExpressionBinding {
                         * parameter yet */
                        param.default_expression.accept (codegen);
                
-                       if (!param.no_array_length && param.type_reference != null &&
-                           param.type_reference is ArrayType) {
-                               var array_type = (ArrayType) param.type_reference;
+                       if (!param.no_array_length && param.parameter_type != null &&
+                           param.parameter_type is ArrayType) {
+                               var array_type = (ArrayType) param.parameter_type;
                                for (int dim = 1; dim <= array_type.rank; dim++) {
                                        carg_map.set (codegen.get_param_pos (param.carray_length_parameter_position + 0.01 * dim), codegen.get_array_length_cexpression (param.default_expression, dim));
                                }

diff --git a/gobject/valaccodememberaccessbinding.vala b/gobject/valaccodememberaccessbinding.vala
index 5be838caf8d58c85a8b6ef7d7a36e51a3ac5b6e3..0d79a0f042101958140d3b006ad4ffc643a9a4f0 100644 (file)
--- a/gobject/valaccodememberaccessbinding.vala
+++ b/gobject/valaccodememberaccessbinding.vala
@@ -190,7 +190,7 @@ public class Vala.CCodeMemberAccessBinding : CCodeExpressionBinding {
                        if (p.name == "this") {
                                expr.ccodenode = pub_inst;
                        } else {
-                               var type_as_struct = p.type_reference.data_type as Struct;
+                               var type_as_struct = p.parameter_type.data_type as Struct;
                                if (p.direction != ParameterDirection.IN
                                    || (type_as_struct != null && !type_as_struct.is_simple_type ())) {
                                        expr.ccodenode = new CCodeIdentifier ("(*%s)".printf (p.name));

diff --git a/gobject/valaccodemethodbinding.vala b/gobject/valaccodemethodbinding.vala
index b3633b2e44c1cfaa5c57a0783265a1fa0310f791..eff5f944647c7d8f35d869cc0a6b5b4fce627443 100644 (file)
--- a/gobject/valaccodemethodbinding.vala
+++ b/gobject/valaccodemethodbinding.vala
@@ -251,10 +251,10 @@ public class Vala.CCodeMethodBinding : CCodeBinding {
                                                break;
                                        }
 
-                                       var t = param.type_reference.data_type;
+                                       var t = param.parameter_type.data_type;
                                        if (t != null && t.is_reference_type ()) {
                                                if (param.direction != ParameterDirection.OUT) {
-                                                       var type_check = create_method_type_check_statement (m, creturn_type, t, (codegen.context.non_null && !param.type_reference.nullable), param.name);
+                                                       var type_check = create_method_type_check_statement (m, creturn_type, t, (codegen.context.non_null && !param.parameter_type.nullable), param.name);
                                                        if (type_check != null) {
                                                                type_check.line = codegen.function.line;
                                                                cinit.append (type_check);
@@ -403,8 +403,8 @@ public class Vala.CCodeMethodBinding : CCodeBinding {
                
                        var params = m.get_parameters ();
                        foreach (FormalParameter param in params) {
-                               if (!param.no_array_length && param.type_reference is ArrayType) {
-                                       var array_type = (ArrayType) param.type_reference;
+                               if (!param.no_array_length && param.parameter_type is ArrayType) {
+                                       var array_type = (ArrayType) param.parameter_type;
                                        
                                        var length_ctype = "int";
                                        if (param.direction != ParameterDirection.IN) {
@@ -421,8 +421,8 @@ public class Vala.CCodeMethodBinding : CCodeBinding {
                                cparam_map.set (codegen.get_param_pos (param.cparameter_position), (CCodeFormalParameter) param.ccodenode);
                                carg_map.set (codegen.get_param_pos (param.cparameter_position), new CCodeIdentifier (param.name));
 
-                               if (param.type_reference is DelegateType) {
-                                       var deleg_type = (DelegateType) param.type_reference;
+                               if (param.parameter_type is DelegateType) {
+                                       var deleg_type = (DelegateType) param.parameter_type;
                                        var d = deleg_type.delegate_symbol;
                                        if (d.has_target) {
                                                var cparam = new CCodeFormalParameter (codegen.get_delegate_target_cname (param.name), "void*");
@@ -588,8 +588,8 @@ public class Vala.CCodeMethodBinding : CCodeBinding {
 
        public void generate_cparameters (Method m, DataType creturn_type, Map<int,CCodeFormalParameter> cparam_map, CCodeFunction func, CCodeFunctionDeclarator? vdeclarator = null) {
                foreach (FormalParameter param in m.get_parameters ()) {
-                       if (!param.no_array_length && param.type_reference is ArrayType) {
-                               var array_type = (ArrayType) param.type_reference;
+                       if (!param.no_array_length && param.parameter_type is ArrayType) {
+                               var array_type = (ArrayType) param.parameter_type;
                                
                                var length_ctype = "int";
                                if (param.direction != ParameterDirection.IN) {
@@ -604,14 +604,14 @@ public class Vala.CCodeMethodBinding : CCodeBinding {
 
                        cparam_map.set (codegen.get_param_pos (param.cparameter_position), (CCodeFormalParameter) param.ccodenode);
 
-                       if (param.type_reference is DelegateType) {
-                               var deleg_type = (DelegateType) param.type_reference;
+                       if (param.parameter_type is DelegateType) {
+                               var deleg_type = (DelegateType) param.parameter_type;
                                var d = deleg_type.delegate_symbol;
                                if (d.has_target) {
                                        var cparam = new CCodeFormalParameter (codegen.get_delegate_target_cname (param.name), "void*");
                                        cparam_map.set (codegen.get_param_pos (param.cdelegate_target_parameter_position), cparam);
                                }
-                       } else if (param.type_reference is MethodType) {
+                       } else if (param.parameter_type is MethodType) {
                                var cparam = new CCodeFormalParameter (codegen.get_delegate_target_cname (param.name), "void*");
                                cparam_map.set (codegen.get_param_pos (param.cdelegate_target_parameter_position), cparam);
                        }
@@ -746,12 +746,12 @@ public class Vala.CCodeMethodBinding : CCodeBinding {
                        return false;
                }
                
-               if (!(param.type_reference is ArrayType)) {
+               if (!(param.parameter_type is ArrayType)) {
                        // parameter must be an array
                        return false;
                }
                
-               var array_type = (ArrayType) param.type_reference;
+               var array_type = (ArrayType) param.parameter_type;
                if (array_type.element_type.data_type != codegen.string_type.data_type) {
                        // parameter must be an array of strings
                        return false;

diff --git a/gobject/valaccodetypesymbolbinding.vala b/gobject/valaccodetypesymbolbinding.vala
index f10f01946f82ea00b309c75871ce694408c33cfb..360b5cef668c3a7368ad7a95d62e67132e6e0c81 100644 (file)
--- a/gobject/valaccodetypesymbolbinding.vala
+++ b/gobject/valaccodetypesymbolbinding.vala
@@ -193,12 +193,12 @@ public abstract class Vala.CCodeTypesymbolBinding : CCodeBinding {
                }
                csignew.add_argument (new CCodeConstant ("%d".printf (params_len)));
                foreach (FormalParameter param in params) {
-                       if (param.type_reference is PointerType || param.type_reference.type_parameter != null || param.direction != ParameterDirection.IN) {
+                       if (param.parameter_type is PointerType || param.parameter_type.type_parameter != null || param.direction != ParameterDirection.IN) {
                                csignew.add_argument (new CCodeConstant ("G_TYPE_POINTER"));
-                       } else if (param.type_reference is ErrorType) {
+                       } else if (param.parameter_type is ErrorType) {
                                csignew.add_argument (new CCodeConstant ("G_TYPE_POINTER"));
                        } else {
-                               csignew.add_argument (new CCodeConstant (param.type_reference.data_type.get_type_id ()));
+                               csignew.add_argument (new CCodeConstant (param.parameter_type.data_type.get_type_id ()));
                        }
                }
 

diff --git a/gobject/valagidlwriter.vala b/gobject/valagidlwriter.vala
index da14caa33aa5562f728604cade8604c08d7cd80e..e772a97675ca66d06567fd7e8896b86f3dc94c79 100644 (file)
--- a/gobject/valagidlwriter.vala
+++ b/gobject/valagidlwriter.vala
@@ -319,22 +319,22 @@ public class Vala.GIdlWriter : CodeVisitor {
 
                foreach (FormalParameter param in params) {
                        write_indent ();
-                       stream.printf ("<parameter name=\"%s\" type=\"%s\"", param.name, get_gidl_type_name (param.type_reference));
+                       stream.printf ("<parameter name=\"%s\" type=\"%s\"", param.name, get_gidl_type_name (param.parameter_type));
                        if (param.direction == ParameterDirection.REF) {
                                stream.printf (" direction=\"inout\"");
                                // in/out paramter
-                               if (param.type_reference.takes_ownership) {
+                               if (param.parameter_type.takes_ownership) {
                                        stream.printf (" transfer=\"full\"");
                                }
                        } else if (param.direction == ParameterDirection.OUT) {
                                // out paramter
                                stream.printf (" direction=\"out\"");
-                               if (param.type_reference.takes_ownership) {
+                               if (param.parameter_type.takes_ownership) {
                                        stream.printf (" transfer=\"full\"");
                                }
                        } else {
                                // normal in paramter
-                               if (param.type_reference.transfers_ownership) {
+                               if (param.parameter_type.transfers_ownership) {
                                        stream.printf (" transfer=\"full\"");
                                }
                        }

diff --git a/vala/valadelegate.vala b/vala/valadelegate.vala
index 055977cc1122b898dfbb9b6451d5802d68cf9d77..499d8f1cefe7e2ce02c6f2f5e4e98f197ec218f7 100644 (file)
--- a/vala/valadelegate.vala
+++ b/vala/valadelegate.vala
@@ -177,7 +177,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.type_reference.stricter (method_param.type_reference)) {
+                       if (!param.parameter_type.stricter (method_param.parameter_type)) {
                                return false;
                        }
                }

diff --git a/vala/valaformalparameter.vala b/vala/valaformalparameter.vala
index 98832315dd08d50de473baf2cbd44c75f4760599..0cae171d2b19dd2747138bfd1b95d862429d01f3 100644 (file)
--- a/vala/valaformalparameter.vala
+++ b/vala/valaformalparameter.vala
@@ -31,7 +31,7 @@ public class Vala.FormalParameter : Symbol {
        /**
         * The parameter type.
         */
-       public DataType type_reference {
+       public DataType parameter_type {
                get { return _data_type; }
                set {
                        _data_type = value;
@@ -92,10 +92,10 @@ public class Vala.FormalParameter : Symbol {
         * @param source reference to source code
         * @return       newly created formal parameter
         */
-       public FormalParameter (string _name, DataType type, SourceReference? source = null) {
-               name = _name;
-               type_reference = type;
-               source_reference = source;
+       public FormalParameter (string name, DataType parameter_type, SourceReference? source_reference = null) {
+               this.name = name;
+               this.parameter_type = parameter_type;
+               this.source_reference = source_reference;
        }
        
        /**
@@ -117,7 +117,7 @@ public class Vala.FormalParameter : Symbol {
 
        public override void accept_children (CodeVisitor visitor) {
                if (!ellipsis) {
-                       type_reference.accept (visitor);
+                       parameter_type.accept (visitor);
                        
                        if (default_expression != null) {
                                default_expression.accept (visitor);
@@ -126,8 +126,8 @@ public class Vala.FormalParameter : Symbol {
        }
 
        public override void replace_type (DataType old_type, DataType new_type) {
-               if (type_reference == old_type) {
-                       type_reference = new_type;
+               if (parameter_type == old_type) {
+                       parameter_type = new_type;
                }
        }
 
@@ -153,7 +153,7 @@ public class Vala.FormalParameter : Symbol {
 
        public FormalParameter copy () {
                if (!ellipsis) {
-                       var result = new FormalParameter (name, type_reference, source_reference);
+                       var result = new FormalParameter (name, parameter_type, source_reference);
                        return result;
                } else {
                        return new FormalParameter.with_ellipsis ();

diff --git a/vala/valainterfacewriter.vala b/vala/valainterfacewriter.vala
index 666fd6bf037c405a7522ec2a11277c207a3b1d21..7a7e99a66325932bce91e4f710e08d0d8b55ea79 100644 (file)
--- a/vala/valainterfacewriter.vala
+++ b/vala/valainterfacewriter.vala
@@ -538,14 +538,14 @@ public class Vala.InterfaceWriter : CodeVisitor {
                                } else if (param.direction == ParameterDirection.OUT) {
                                        write_string ("out ");
                                }
-                               if (param.type_reference.data_type != null && param.type_reference.data_type.is_reference_type () && !param.type_reference.takes_ownership) {
+                               if (param.parameter_type.data_type != null && param.parameter_type.data_type.is_reference_type () && !param.parameter_type.takes_ownership) {
                                        write_string ("weak ");
                                }
                        }
 
-                       write_type (param.type_reference);
+                       write_type (param.parameter_type);
 
-                       if (param.type_reference.transfers_ownership) {
+                       if (param.parameter_type.transfers_ownership) {
                                write_string ("#");
                        }
 
@@ -625,7 +625,7 @@ public class Vala.InterfaceWriter : CodeVisitor {
                if (m.no_array_length) {
                        bool array_found = (m.return_type is ArrayType);
                        foreach (FormalParameter param in m.get_parameters ()) {
-                               if (param.type_reference is ArrayType) {
+                               if (param.parameter_type is ArrayType) {
                                        array_found = true;
                                        break;
                                }

diff --git a/vala/valamemorymanager.vala b/vala/valamemorymanager.vala
index e6133feb48cbdd4ca5efc9709b5b6821cdc08ffc..1a2f3f56553210c300ddac313a71f6deab6709a3 100644 (file)
--- a/vala/valamemorymanager.vala
+++ b/vala/valamemorymanager.vala
@@ -245,12 +245,12 @@ public class Vala.MemoryManager : CodeVisitor {
                        if (params_it.next ()) {
                                var param = params_it.get ();
                                if (!param.ellipsis
-                                   && param.type_reference.is_reference_type_or_type_parameter ()) {
-                                       bool is_ref = param.type_reference.transfers_ownership;
-                                       if (is_ref && param.type_reference.type_parameter != null) {
+                                   && param.parameter_type.is_reference_type_or_type_parameter ()) {
+                                       bool is_ref = param.parameter_type.transfers_ownership;
+                                       if (is_ref && param.parameter_type.type_parameter != null) {
                                                if (expr.call is MemberAccess) {
                                                        var ma = (MemberAccess) expr.call;
-                                                       var param_type = SemanticAnalyzer.get_actual_type (ma.inner.value_type, ma.symbol_reference, param.type_reference, expr);
+                                                       var param_type = SemanticAnalyzer.get_actual_type (ma.inner.value_type, ma.symbol_reference, param.parameter_type, expr);
                                                        if (param_type != null) {
                                                                is_ref = param_type.takes_ownership;
                                                        }
@@ -286,10 +286,10 @@ public class Vala.MemoryManager : CodeVisitor {
                        if (params_it.next ()) {
                                var param = params_it.get ();
                                if (!param.ellipsis
-                                   && param.type_reference.is_reference_type_or_type_parameter ()) {
-                                       bool is_ref = param.type_reference.transfers_ownership;
-                                       if (is_ref && param.type_reference.type_parameter != null) {
-                                               var param_type = SemanticAnalyzer.get_actual_type (expr.type_reference, msym, param.type_reference, expr);
+                                   && param.parameter_type.is_reference_type_or_type_parameter ()) {
+                                       bool is_ref = param.parameter_type.transfers_ownership;
+                                       if (is_ref && param.parameter_type.type_parameter != null) {
+                                               var param_type = SemanticAnalyzer.get_actual_type (expr.type_reference, msym, param.parameter_type, expr);
                                                if (param_type != null) {
                                                        is_ref = param_type.takes_ownership;
                                                }

diff --git a/vala/valamethod.vala b/vala/valamethod.vala
index bda8b9d5a91adfeb0e6d3707aa513b275da8617f..929fd254194a22dea2507b34e49241bf05457c4b 100644 (file)
--- a/vala/valamethod.vala
+++ b/vala/valamethod.vala
@@ -405,7 +405,7 @@ public class Vala.Method : Member {
                                return false;
                        }
                        
-                       if (!base_param.type_reference.equals (method_params_it.get ().type_reference)) {
+                       if (!base_param.parameter_type.equals (method_params_it.get ().parameter_type)) {
                                invalid_match = "incompatible type of parameter %d".printf (param_index);
                                return false;
                        }

diff --git a/vala/valanullchecker.vala b/vala/valanullchecker.vala
index 12a7a6f3c38c2d761f6feffe6a88d762e396cb61..fb68fd25de64548be1650f0d9d2205fad772aa8e 100644 (file)
--- a/vala/valanullchecker.vala
+++ b/vala/valanullchecker.vala
@@ -102,7 +102,7 @@ public class Vala.NullChecker : CodeVisitor {
                p.accept_children (this);
 
                if (p.default_expression != null) {
-                       check_compatible (p.default_expression, p.type_reference);
+                       check_compatible (p.default_expression, p.parameter_type);
                }
        }
 

diff --git a/vala/valasemanticanalyzer.vala b/vala/valasemanticanalyzer.vala
index 7227d6a13b135f63e3bf457b2d655ff9f70e091f..1c3b81292c0f27c7cd977095c97a2fe2dfc8b8e2 100644 (file)
--- a/vala/valasemanticanalyzer.vala
+++ b/vala/valasemanticanalyzer.vala
@@ -549,22 +549,22 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
 
                if (context.non_null && p.default_expression != null) {
                        if (p.default_expression is NullLiteral
-                           && !p.type_reference.nullable
+                           && !p.parameter_type.nullable
                            && p.direction != ParameterDirection.OUT) {
-                               Report.warning (p.source_reference, "`null' incompatible with parameter type `%s`".printf (p.type_reference.to_string ()));
+                               Report.warning (p.source_reference, "`null' incompatible with parameter type `%s`".printf (p.parameter_type.to_string ()));
                        }
                }
 
                if (!p.ellipsis) {
                        if (!p.is_internal_symbol ()) {
-                               current_source_file.add_type_dependency (p.type_reference, SourceFileDependencyType.HEADER_SHALLOW);
+                               current_source_file.add_type_dependency (p.parameter_type, SourceFileDependencyType.HEADER_SHALLOW);
                        }
-                       current_source_file.add_type_dependency (p.type_reference, SourceFileDependencyType.SOURCE);
+                       current_source_file.add_type_dependency (p.parameter_type, SourceFileDependencyType.SOURCE);
 
                        // check whether parameter type is at least as accessible as the method
-                       if (!is_type_accessible (p, p.type_reference)) {
+                       if (!is_type_accessible (p, p.parameter_type)) {
                                p.error = true;
-                               Report.error (p.source_reference, "parameter type `%s` is less accessible than method `%s`".printf (p.type_reference.to_string (), p.parent_symbol.get_full_name ()));
+                               Report.error (p.source_reference, "parameter type `%s` is less accessible than method `%s`".printf (p.parameter_type.to_string (), p.parent_symbol.get_full_name ()));
                                return;
                        }
                }
@@ -1397,7 +1397,7 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
                        return type;
                } else if (sym is FormalParameter) {
                        var p = (FormalParameter) sym;
-                       var type = p.type_reference.copy ();
+                       var type = p.parameter_type.copy ();
                        type.transfers_ownership = false;
                        return type;
                } else if (sym is DataType) {
@@ -1785,7 +1785,7 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
                                Expression arg = arg_it.get ();
 
                                /* store expected type for callback parameters */
-                               arg.expected_type = param.type_reference;
+                               arg.expected_type = param.parameter_type;
                        }
                }
 
@@ -1856,7 +1856,7 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
                        }
 
                        /* header file necessary if we need to cast argument */
-                       current_source_file.add_type_dependency (param.type_reference, SourceFileDependencyType.SOURCE);
+                       current_source_file.add_type_dependency (param.parameter_type, SourceFileDependencyType.SOURCE);
 
                        if (!arg_it.next ()) {
                                if (param.default_expression == null) {
@@ -1872,15 +1872,15 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
                                        return false;
                                } else if (arg.value_type == null) {
                                        // disallow untyped arguments except for type inference of callbacks
-                                       if (!(param.type_reference is DelegateType) || !(arg.symbol_reference is Method)) {
+                                       if (!(param.parameter_type is DelegateType) || !(arg.symbol_reference is Method)) {
                                                expr.error = true;
                                                Report.error (arg.source_reference, "Invalid type for argument %d".printf (i + 1));
                                                return false;
                                        }
-                               } else if (!arg.value_type.compatible (param.type_reference)
+                               } else if (!arg.value_type.compatible (param.parameter_type)
                                           && !(arg is NullLiteral && param.direction == ParameterDirection.OUT)) {
                                        expr.error = true;
-                                       Report.error (arg.source_reference, "Argument %d: Cannot convert from `%s' to `%s'".printf (i + 1, arg.value_type.to_string (), param.type_reference.to_string ()));
+                                       Report.error (arg.source_reference, "Argument %d: Cannot convert from `%s' to `%s'".printf (i + 1, arg.value_type.to_string (), param.parameter_type.to_string ()));
                                        return false;
                                } else {
                                        // 0 => null, 1 => in, 2 => ref, 3 => out
@@ -1901,7 +1901,7 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
                                                        expr.error = true;
                                                        Report.error (arg.source_reference, "Argument %d: Cannot pass null to reference parameter".printf (i + 1));
                                                        return false;
-                                               } else if (context.non_null && param.direction != ParameterDirection.OUT && !param.type_reference.nullable) {
+                                               } else if (context.non_null && param.direction != ParameterDirection.OUT && !param.parameter_type.nullable) {
                                                        Report.warning (arg.source_reference, "Argument %d: Cannot pass null to non-null parameter type".printf (i + 1));
                                                }
                                        } else if (arg_type == 1) {
@@ -2159,9 +2159,9 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
                        get_params_it.next ();
                        var get_param = get_params_it.get ();
 
-                       var index_type = get_param.type_reference;
+                       var index_type = get_param.parameter_type;
                        if (index_type.type_parameter != null) {
-                               index_type = get_actual_type (expr.container.value_type, get_method, get_param.type_reference, expr);
+                               index_type = get_actual_type (expr.container.value_type, get_method, get_param.parameter_type, expr);
                        }
 
                        if (!index.value_type.compatible (index_type)) {
@@ -2409,7 +2409,7 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
                                        Expression arg = arg_it.get ();
 
                                        /* store expected type for callback parameters */
-                                       arg.expected_type = param.type_reference;
+                                       arg.expected_type = param.parameter_type;
                                }
                        }
 
@@ -2931,7 +2931,7 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
 
                        string lambda_param = lambda_param_it.get ();
 
-                       var param = new FormalParameter (lambda_param, cb_param.type_reference);
+                       var param = new FormalParameter (lambda_param, cb_param.parameter_type);
 
                        l.method.add_parameter (param);
                }

diff --git a/vala/valasourcefile.vala b/vala/valasourcefile.vala
index 662d8cd70c07f3011882b3ff96e15bf26d6ef50d..f64e3dcbd7555e4fd897db2ce8c7590841789dec 100644 (file)
--- a/vala/valasourcefile.vala
+++ b/vala/valasourcefile.vala
@@ -245,7 +245,7 @@ public class Vala.SourceFile : Object {
                        s = sym;
                } else if (sym is FormalParameter) {
                        var fp = (FormalParameter) sym;
-                       s = fp.type_reference.data_type;
+                       s = fp.parameter_type.data_type;
                        if (s == null) {
                                /* generic type parameter */
                                return;