Improve get_actual_type signature

2008-11-28  Jürg Billeter  <j@bitron.ch>

	* vala/valabinaryexpression.vala:
	* vala/valaelementaccess.vala:
	* vala/valaforeachstatement.vala:
	* vala/valamemberaccess.vala:
	* vala/valamethodcall.vala:
	* vala/valasemanticanalyzer.vala:
	* gobject/valaccodearraymodule.vala:
	* gobject/valaccodeassignmentmodule.vala:
	* gobject/valaccodecontrolflowmodule.vala:

	Improve get_actual_type signature

svn path=/trunk/; revision=2066

diff --git a/ChangeLog b/ChangeLog
index cb2c4c9634ca21836a34bd6e47e3f92adde33e86..db6ca5801e2db419d3c5fd8d31e3fe6b849188f5 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,17 @@
+2008-11-28  Jürg Billeter  <j@bitron.ch>
+
+       * vala/valabinaryexpression.vala:
+       * vala/valaelementaccess.vala:
+       * vala/valaforeachstatement.vala:
+       * vala/valamemberaccess.vala:
+       * vala/valamethodcall.vala:
+       * vala/valasemanticanalyzer.vala:
+       * gobject/valaccodearraymodule.vala:
+       * gobject/valaccodeassignmentmodule.vala:
+       * gobject/valaccodecontrolflowmodule.vala:
+
+       Improve get_actual_type signature
+
 2008-11-28  Jürg Billeter  <j@bitron.ch>
 
        * vala/Makefile.am:

diff --git a/gobject/valaccodearraymodule.vala b/gobject/valaccodearraymodule.vala
index ef302dd4cfc38e00ac09696d3a601705c586c0f3..b3a4590347a6292ca7d61f8ddacf3166969a6d81 100644 (file)
--- a/gobject/valaccodearraymodule.vala
+++ b/gobject/valaccodearraymodule.vala
@@ -270,8 +270,8 @@ public class Vala.CCodeArrayModule : CCodeMethodCallModule {
                        get_params_it.next ();
                        var get_param = get_params_it.get ();
 
-                       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);
+                       if (get_param.parameter_type is GenericType) {
+                               var index_type = SemanticAnalyzer.get_actual_type (expr.container.value_type, (GenericType) get_param.parameter_type, expr);
                                cindex = convert_to_generic_pointer (cindex, index_type);
                        }
 

diff --git a/gobject/valaccodeassignmentmodule.vala b/gobject/valaccodeassignmentmodule.vala
index 4f38899efcc6d2beed0bdb091c7b2b6f77a0ad59..91395801bde30b842f8b87205553ea9992079b55 100644 (file)
--- a/gobject/valaccodeassignmentmodule.vala
+++ b/gobject/valaccodeassignmentmodule.vala
@@ -119,8 +119,8 @@ public class Vala.CCodeAssignmentModule : CCodeMemberAccessModule {
                        set_params_it.next ();
                        var set_param = set_params_it.get ();
 
-                       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);
+                       if (set_param.parameter_type is GenericType) {
+                               var index_type = SemanticAnalyzer.get_actual_type (expr.container.value_type, (GenericType) set_param.parameter_type, assignment);
                                cindex = convert_to_generic_pointer (cindex, index_type);
                        }
 

diff --git a/gobject/valaccodecontrolflowmodule.vala b/gobject/valaccodecontrolflowmodule.vala
index 011bc30c5880837af46eb230247966461caa6c36..340b2584e7d33bf07cd79c6e664f3184eb67bb2e 100644 (file)
--- a/gobject/valaccodecontrolflowmodule.vala
+++ b/gobject/valaccodecontrolflowmodule.vala
@@ -470,7 +470,7 @@ public class Vala.CCodeControlFlowModule : CCodeMethodModule {
                        get_ccall.add_argument (new CCodeIdentifier (it_name));
                        CCodeExpression element_expr = get_ccall;
 
-                       var element_type = SemanticAnalyzer.get_actual_type (stmt.collection.value_type, get_method, get_method.return_type, stmt);
+                       var element_type = SemanticAnalyzer.get_actual_type (stmt.collection.value_type, (GenericType) get_method.return_type, stmt);
 
                        element_expr = transform_expression (element_expr, element_type, stmt.type_reference);
 
@@ -520,7 +520,7 @@ public class Vala.CCodeControlFlowModule : CCodeMethodModule {
 
                        Iterator<DataType> type_arg_it = it_method.return_type.get_type_arguments ().iterator ();
                        type_arg_it.next ();
-                       var it_type = SemanticAnalyzer.get_actual_type (stmt.collection.value_type, it_method, type_arg_it.get (), stmt);
+                       var it_type = SemanticAnalyzer.get_actual_type (stmt.collection.value_type, (GenericType) type_arg_it.get (), stmt);
 
                        element_expr = transform_expression (element_expr, it_type, stmt.type_reference);
 

diff --git a/vala/valabinaryexpression.vala b/vala/valabinaryexpression.vala
index 200bb711db6af6de7ccf89003a889814b926d236..1a10b74db56763ab6c97f7be490de30c98cefe0c 100644 (file)
--- a/vala/valabinaryexpression.vala
+++ b/vala/valabinaryexpression.vala
@@ -288,7 +288,7 @@ public class Vala.BinaryExpression : Expression {
                                contains_params_it.next ();
                                var contains_param = contains_params_it.get ();
 
-                               var key_type = analyzer.get_actual_type (right.value_type, contains_method, contains_param.parameter_type, this);
+                               var key_type = analyzer.get_actual_type (right.value_type, (GenericType) contains_param.parameter_type, this);
                                left.target_type = key_type;
                        }
                        

diff --git a/vala/valaelementaccess.vala b/vala/valaelementaccess.vala
index 7b40354eee58a69a53d3b8ea52148f2c5bae4e16..8475187637f8769b865a1d2e8173159855190c25 100644 (file)
--- a/vala/valaelementaccess.vala
+++ b/vala/valaelementaccess.vala
@@ -165,8 +165,8 @@ public class Vala.ElementAccess : Expression {
                        var get_param = get_params_it.get ();
 
                        var index_type = get_param.parameter_type;
-                       if (index_type.type_parameter != null) {
-                               index_type = analyzer.get_actual_type (container.value_type, get_method, get_param.parameter_type, this);
+                       if (index_type is GenericType) {
+                               index_type = analyzer.get_actual_type (container.value_type, (GenericType) index_type, this);
                        }
 
                        if (!index.value_type.compatible (index_type)) {
@@ -175,7 +175,7 @@ public class Vala.ElementAccess : Expression {
                                return false;
                        }
 
-                       value_type = analyzer.get_actual_type (container.value_type, get_method, get_method.return_type, this).copy ();
+                       value_type = analyzer.get_actual_type (container.value_type, (GenericType) get_method.return_type, this).copy ();
                        if (lvalue) {
                                // get () returns owned value, set () accepts unowned value
                                value_type.value_owned = false;

diff --git a/vala/valaforeachstatement.vala b/vala/valaforeachstatement.vala
index 5e39ab532a4f05927b371e630e80b00e155f5cc8..04c196590f636b2efe0d1729017d0c5cb3432d15 100644 (file)
--- a/vala/valaforeachstatement.vala
+++ b/vala/valaforeachstatement.vala
@@ -183,8 +183,8 @@ public class Vala.ForeachStatement : Block {
                        var it_method = (Method) analyzer.iterable_type.data_type.scope.lookup ("iterator");
                        if (it_method.return_type.get_type_arguments ().size > 0) {
                                var type_arg = it_method.return_type.get_type_arguments ().get (0);
-                               if (type_arg.type_parameter != null) {
-                                       element_data_type = SemanticAnalyzer.get_actual_type (collection_type, it_method, type_arg, this);
+                               if (type_arg is GenericType) {
+                                       element_data_type = SemanticAnalyzer.get_actual_type (collection_type, (GenericType) type_arg, this);
                                } else {
                                        element_data_type = type_arg;
                                }

diff --git a/vala/valamemberaccess.vala b/vala/valamemberaccess.vala
index 9dcb342b860a619a225273bc845414a62eb29b4b..c5c9cce66c64b15f78a0dfd8b5bbbfc62e36fbd9 100644 (file)
--- a/vala/valamemberaccess.vala
+++ b/vala/valamemberaccess.vala
@@ -490,9 +490,9 @@ public class Vala.MemberAccess : Expression {
                        value_type = analyzer.get_value_type_for_symbol (symbol_reference, lvalue);
 
                        // resolve generic return values
-                       if (value_type != null && value_type.type_parameter != null) {
+                       if (value_type is GenericType) {
                                if (inner != null) {
-                                       value_type = analyzer.get_actual_type (inner.value_type, symbol_reference, value_type, this);
+                                       value_type = analyzer.get_actual_type (inner.value_type, (GenericType) value_type, this);
                                        if (value_type == null) {
                                                return false;
                                        }

diff --git a/vala/valamethodcall.vala b/vala/valamethodcall.vala
index 0dc389802de3fbfa4a4189c3d87d2e7ae4b7545d..4e2f92332c40cd763a1138ff7a9e228008af3d4e 100644 (file)
--- a/vala/valamethodcall.vala
+++ b/vala/valamethodcall.vala
@@ -224,9 +224,9 @@ public class Vala.MethodCall : Expression {
 
                                // resolve generic type parameters
                                var ma = call as MemberAccess;
-                               if (arg.target_type.type_parameter != null) {
+                               if (arg.target_type is GenericType) {
                                        if (ma != null && ma.inner != null) {
-                                               arg.target_type = analyzer.get_actual_type (ma.inner.value_type, ma.symbol_reference, arg.target_type, arg);
+                                               arg.target_type = analyzer.get_actual_type (ma.inner.value_type, (GenericType) arg.target_type, arg);
                                                assert (arg.target_type != null);
                                        }
                                }
@@ -393,9 +393,9 @@ public class Vala.MethodCall : Expression {
 
                // resolve generic return values
                var ma = call as MemberAccess;
-               if (ret_type.type_parameter != null) {
+               if (ret_type is GenericType) {
                        if (ma != null && ma.inner != null) {
-                               ret_type = analyzer.get_actual_type (ma.inner.value_type, ma.symbol_reference, ret_type, this);
+                               ret_type = analyzer.get_actual_type (ma.inner.value_type, (GenericType) ret_type, this);
                                if (ret_type == null) {
                                        return false;
                                }
@@ -403,8 +403,8 @@ public class Vala.MethodCall : Expression {
                }
                Gee.List<DataType> resolved_type_args = new ArrayList<DataType> ();
                foreach (DataType type_arg in ret_type.get_type_arguments ()) {
-                       if (type_arg.type_parameter != null && ma != null && ma.inner != null) {
-                               resolved_type_args.add (analyzer.get_actual_type (ma.inner.value_type, ma.symbol_reference, type_arg, this));
+                       if (type_arg is GenericType && ma != null && ma.inner != null) {
+                               resolved_type_args.add (analyzer.get_actual_type (ma.inner.value_type, (GenericType) type_arg, this));
                        } else {
                                resolved_type_args.add (type_arg);
                        }

diff --git a/vala/valasemanticanalyzer.vala b/vala/valasemanticanalyzer.vala
index 94b6256be5b2e788517e555ff0858c0ae71399dd..f23448b4592562b578991421435d1221ced3f51a 100644 (file)
--- a/vala/valasemanticanalyzer.vala
+++ b/vala/valasemanticanalyzer.vala
@@ -474,7 +474,7 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
                return instance_base_type;
        }
 
-       static DataType? get_instance_base_type_for_member (DataType derived_instance_type, Symbol member, CodeNode node_reference) {
+       static DataType? get_instance_base_type_for_member (DataType derived_instance_type, TypeSymbol type_symbol, CodeNode node_reference) {
                DataType instance_type = derived_instance_type;
 
                while (instance_type is PointerType) {
@@ -482,7 +482,7 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
                        instance_type = instance_pointer_type.base_type;
                }
 
-               if (instance_type.data_type == member.parent_symbol) {
+               if (instance_type.data_type == type_symbol) {
                        return instance_type;
                }
 
@@ -495,7 +495,7 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
                        // (prerequisites can be assumed to be met already)
                        foreach (DataType base_type in cl.get_base_types ()) {
                                if (base_type.data_type is Interface) {
-                                       instance_base_type = get_instance_base_type_for_member (get_instance_base_type (instance_type, base_type, node_reference), member, node_reference);
+                                       instance_base_type = get_instance_base_type_for_member (get_instance_base_type (instance_type, base_type, node_reference), type_symbol, node_reference);
                                        if (instance_base_type != null) {
                                                return instance_base_type;
                                        }
@@ -505,7 +505,7 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
                        if (instance_base_type == null) {
                                foreach (DataType base_type in cl.get_base_types ()) {
                                        if (base_type.data_type is Class) {
-                                               instance_base_type = get_instance_base_type_for_member (get_instance_base_type (instance_type, base_type, node_reference), member, node_reference);
+                                               instance_base_type = get_instance_base_type_for_member (get_instance_base_type (instance_type, base_type, node_reference), type_symbol, node_reference);
                                                if (instance_base_type != null) {
                                                        return instance_base_type;
                                                }
@@ -515,7 +515,7 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
                } else if (instance_type.data_type is Struct) {
                        var st = (Struct) instance_type.data_type;
                        foreach (DataType base_type in st.get_base_types ()) {
-                               instance_base_type = get_instance_base_type_for_member (get_instance_base_type (instance_type, base_type, node_reference), member, node_reference);
+                               instance_base_type = get_instance_base_type_for_member (get_instance_base_type (instance_type, base_type, node_reference), type_symbol, node_reference);
                                if (instance_base_type != null) {
                                        return instance_base_type;
                                }
@@ -525,7 +525,7 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
                        // first check interface prerequisites recursively
                        foreach (DataType prerequisite in iface.get_prerequisites ()) {
                                if (prerequisite.data_type is Interface) {
-                                       instance_base_type = get_instance_base_type_for_member (get_instance_base_type (instance_type, prerequisite, node_reference), member, node_reference);
+                                       instance_base_type = get_instance_base_type_for_member (get_instance_base_type (instance_type, prerequisite, node_reference), type_symbol, node_reference);
                                        if (instance_base_type != null) {
                                                return instance_base_type;
                                        }
@@ -535,7 +535,7 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
                                // then check class prerequisite recursively
                                foreach (DataType prerequisite in iface.get_prerequisites ()) {
                                        if (prerequisite.data_type is Class) {
-                                               instance_base_type = get_instance_base_type_for_member (get_instance_base_type (instance_type, prerequisite, node_reference), member, node_reference);
+                                               instance_base_type = get_instance_base_type_for_member (get_instance_base_type (instance_type, prerequisite, node_reference), type_symbol, node_reference);
                                                if (instance_base_type != null) {
                                                        return instance_base_type;
                                                }
@@ -547,15 +547,11 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
                return null;
        }
 
-       public static DataType? get_actual_type (DataType derived_instance_type, Symbol generic_member, DataType generic_type, CodeNode node_reference) {
+       public static DataType? get_actual_type (DataType derived_instance_type, GenericType generic_type, CodeNode node_reference) {
                // trace type arguments back to the datatype where the method has been declared
-               var instance_type = get_instance_base_type_for_member (derived_instance_type, generic_member, node_reference);
+               var instance_type = get_instance_base_type_for_member (derived_instance_type, (TypeSymbol) generic_type.type_parameter.parent_symbol, node_reference);
 
-               if (instance_type == null) {
-                       Report.error (node_reference.source_reference, "internal error: unable to find generic member `%s'".printf (generic_member.name));
-                       node_reference.error = true;
-                       return null;
-               }
+               assert (instance_type != null);
 
                int param_index = instance_type.data_type.get_type_parameter_index (generic_type.type_parameter.name);
                if (param_index == -1) {