reduce use of raw DataType instances

2008-03-04  Juerg Billeter  <j@bitron.ch>

	* vala/Makefile.am, vala/valasemanticanalyzer.vala,
	  vala/valasymbolresolver.vala, vala/valatypeparametertype.vala:
	  reduce use of raw DataType instances

svn path=/trunk/; revision=1103

diff --git a/ChangeLog b/ChangeLog
index 1a55526..98389f9 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,11 @@
 2008-03-04  Jürg Billeter  <j@bitron.ch>
 
+       * vala/Makefile.am, vala/valasemanticanalyzer.vala,
+         vala/valasymbolresolver.vala, vala/valatypeparametertype.vala:
+         reduce use of raw DataType instances
+
+2008-03-04  Jürg Billeter  <j@bitron.ch>
+
        * vapi/sqlite3.vapi: fix sqlite3_value binding,
          patch by Andreas Brauchli
 

diff --git a/vala/Makefile.am b/vala/Makefile.am
index 0773936..6bdf0f5 100644 (file)
--- a/vala/Makefile.am
+++ b/vala/Makefile.am
@@ -129,6 +129,7 @@ libvalacore_la_VALASOURCES = \
        valatypecheck.vala \
        valatypeofexpression.vala \
        valatypeparameter.vala \
+       valatypeparametertype.vala \
        valatypesymbol.vala \
        valaunaryexpression.vala \
        valaunresolvedsymbol.vala \

diff --git a/vala/valasemanticanalyzer.vala b/vala/valasemanticanalyzer.vala
index e95111b..ce5eb66 100644 (file)
--- a/vala/valasemanticanalyzer.vala
+++ b/vala/valasemanticanalyzer.vala
@@ -967,7 +967,7 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
                stmt.collection_variable_declarator.active = true;
        
                var collection_type = stmt.collection.static_type;
-               var element_data_type = new DataType ();
+               DataType element_data_type = null;
                bool need_type_check = false;
        
                if (collection_type.is_array ()) {
@@ -2930,7 +2930,7 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
                                var args = ea.container.static_type.get_type_arguments ();
                                if (args.size != 1) {
                                        a.error = true;
-                                       Report.error (ea.source_reference, "internal error: array reference without type arguments");
+                                       Report.error (ea.source_reference, "internal error: array reference with %d type arguments".printf (args.size));
                                        return;
                                }
                                var element_type = args.get (0);

diff --git a/vala/valasymbolresolver.vala b/vala/valasymbolresolver.vala
index c1f5f8b..b2165a4 100644 (file)
--- a/vala/valasymbolresolver.vala
+++ b/vala/valasymbolresolver.vala
@@ -219,17 +219,7 @@ public class Vala.SymbolResolver : CodeVisitor {
        }
 
        private DataType! resolve_type (UnresolvedType! unresolved_type) {
-               var type = new DataType ();
-               type.source_reference = unresolved_type.source_reference;
-               type.takes_ownership = unresolved_type.takes_ownership;
-               type.transfers_ownership = unresolved_type.transfers_ownership;
-               type.is_ref = unresolved_type.is_ref;
-               type.is_out = unresolved_type.is_out;
-               type.nullable = unresolved_type.nullable;
-               type.requires_null_check = unresolved_type.requires_null_check;
-               foreach (DataType type_arg in unresolved_type.get_type_arguments ()) {
-                       type.add_type_argument (type_arg);
-               }
+               DataType type = null;
 
                // still required for vapigen
                if (unresolved_type.unresolved_symbol.name == "void") {
@@ -240,58 +230,56 @@ public class Vala.SymbolResolver : CodeVisitor {
                if (sym == null) {
                        // don't report same error twice
                        if (!unresolved_type.unresolved_symbol.error) {
-                               Report.error (type.source_reference, "The type name `%s' could not be found".printf (unresolved_type.unresolved_symbol.to_string ()));
+                               Report.error (unresolved_type.source_reference, "The type name `%s' could not be found".printf (unresolved_type.unresolved_symbol.to_string ()));
                        }
                        return new InvalidType ();
                }
 
                if (sym is TypeParameter) {
-                       type.type_parameter = (TypeParameter) sym;
+                       type = new TypeParameterType ((TypeParameter) sym);
                } else if (sym is Typesymbol) {
                        if (sym is Delegate) {
                                type = new DelegateType ((Delegate) sym);
+                       } else if (sym is Class) {
+                               var cl = (Class) sym;
+                               if (cl.is_error_base) {
+                                       type = new ErrorType (null);
+                               } else {
+                                       type = new ClassType (cl);
+                               }
+                       } else if (sym is Interface) {
+                               type = new InterfaceType ((Interface) sym);
+                       } else if (sym is Struct) {
+                               type = new ValueType ((Struct) sym);
+                       } else if (sym is Enum) {
+                               type = new ValueType ((Enum) sym);
+                       } else if (sym is ErrorDomain) {
+                               type = new ErrorType ((ErrorDomain) sym);
                        } else {
-                               type.data_type = (Typesymbol) sym;
+                               Report.error (unresolved_type.source_reference, "internal error: `%s' is not a supported type".printf (sym.get_full_name ()));
+                               return new InvalidType ();
                        }
                } else {
-                       Report.error (type.source_reference, "`%s' is not a type".printf (sym.get_full_name ()));
+                       Report.error (unresolved_type.source_reference, "`%s' is not a type".printf (sym.get_full_name ()));
                        return new InvalidType ();
                }
 
+               type.source_reference = unresolved_type.source_reference;
+               type.takes_ownership = unresolved_type.takes_ownership;
+               type.transfers_ownership = unresolved_type.transfers_ownership;
+               type.is_ref = unresolved_type.is_ref;
+               type.is_out = unresolved_type.is_out;
+               type.nullable = unresolved_type.nullable;
+               type.requires_null_check = unresolved_type.requires_null_check;
+               foreach (DataType type_arg in unresolved_type.get_type_arguments ()) {
+                       type.add_type_argument (type_arg);
+               }
+
                for (int pointer_level = unresolved_type.pointer_level; pointer_level > 0; pointer_level--) {
                        type = new PointerType (type);
                }
 
-               /* check for array */
-               if (unresolved_type.array_rank > 0) {
-                       var element_type = new DataType ();
-                       element_type.data_type = type.data_type;
-                       element_type.type_parameter = type.type_parameter;
-                       foreach (DataType type_arg in type.get_type_arguments ()) {
-                               element_type.add_type_argument (type_arg);
-                       }
-
-                       if (type.data_type != null) {
-                               if (type.data_type.is_reference_type ()) {
-                                       element_type.takes_ownership = type.takes_ownership;
-                               }
-                       } else {
-                               element_type.takes_ownership = type.takes_ownership;
-                       }
-
-                       type = new ArrayType (element_type, unresolved_type.array_rank);
-                       type.add_type_argument (element_type);
-
-                       type.source_reference = unresolved_type.source_reference;
-                       type.takes_ownership = unresolved_type.takes_ownership;
-                       type.transfers_ownership = unresolved_type.transfers_ownership;
-                       type.is_ref = unresolved_type.is_ref;
-                       type.is_out = unresolved_type.is_out;
-                       type.nullable = unresolved_type.nullable;
-                       type.requires_null_check = unresolved_type.nullable;
-               }
-               
-               if (type.data_type != null && !type.data_type.is_reference_type ()) {
+               if (!type.is_reference_type_or_type_parameter ()) {
                        /* reset takes_ownership and transfers_ownership of
                         * value-types for contexts where types are ref by
                         * default (field declarations and method return types)
@@ -305,9 +293,23 @@ public class Vala.SymbolResolver : CodeVisitor {
                        }
                }
 
-               /* check whether this type resolved to a ErrorBase class */
-               if (type.data_type is Class && ((Class)type.data_type).is_error_base) {
-                       type = new ErrorType (null);
+               /* check for array */
+               if (unresolved_type.array_rank > 0) {
+                       var element_type = type;
+                       element_type.transfers_ownership = false;
+                       element_type.is_ref = false;
+                       element_type.is_out = false;
+
+                       type = new ArrayType (element_type, unresolved_type.array_rank);
+                       type.add_type_argument (element_type);
+
+                       type.source_reference = unresolved_type.source_reference;
+                       type.takes_ownership = unresolved_type.takes_ownership;
+                       type.transfers_ownership = unresolved_type.transfers_ownership;
+                       type.is_ref = unresolved_type.is_ref;
+                       type.is_out = unresolved_type.is_out;
+                       type.nullable = unresolved_type.nullable;
+                       type.requires_null_check = unresolved_type.nullable;
                }
 
                return type;

diff --git a/vala/valatypeparametertype.vala b/vala/valatypeparametertype.vala
new file mode 100644 (file)
index 0000000..62357f7
--- /dev/null
+++ b/vala/valatypeparametertype.vala
@@ -0,0 +1,32 @@
+/* valatypeparametertype.vala
+ *
+ * Copyright (C) 2008  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>
+ */
+
+using GLib;
+
+/**
+ * The type of a generic type parameter.
+ */
+public class Vala.TypeParameterType : DataType {
+       public TypeParameterType (TypeParameter type_parameter) {
+               this.type_parameter = type_parameter;
+       }
+}