codegen: Inherit GType from base struct of SimpleType structs

GValue functions and marshaller type are inherited from base structs
already.

This avoids invalid C code which referenced an unavailable GType.

diff --git a/codegen/valaccodeattribute.vala b/codegen/valaccodeattribute.vala
index df74b06369594f0b0091b838dc38a54449765a1d..fdd5180e941a0c59298dffdb6e14d5ca760f06e9 100644 (file)
--- a/codegen/valaccodeattribute.vala
+++ b/codegen/valaccodeattribute.vala
@@ -1014,8 +1014,8 @@ public class Vala.CCodeAttribute : AttributeCache {
                                return get_ccode_upper_case_name (sym, "TYPE_");
                        } else if (sym is Struct) {
                                unowned Struct st = (Struct) sym;
-                               if (!get_ccode_has_type_id (st)) {
-                                       unowned Struct? base_struct = st.base_struct;
+                               unowned Struct? base_struct = st.base_struct;
+                               if (!get_ccode_has_type_id (st) || (base_struct != null && base_struct.is_simple_type ())) {
                                        if (base_struct != null) {
                                                return get_ccode_type_id (base_struct);
                                        }

diff --git a/tests/Makefile.am b/tests/Makefile.am
index f88774926f17b7ee5cd7782b9af23ff2ae19d673..fce8f5f2d7c29b70261ef1b41129fc403a568615 100644 (file)
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -336,6 +336,7 @@ TESTS = \
        structs/constructor-wrong-name.test \
        structs/default-gtype.vala \
        structs/gmutex.vala \
+       structs/gtype-base-struct.vala \
        structs/gvalue.vala \
        structs/gvalue-implicit-comparison.vala \
        structs/simple-type-constructor.vala \

diff --git a/tests/structs/gtype-base-struct.vala b/tests/structs/gtype-base-struct.vala
new file mode 100644 (file)
index 0000000..3a4c2b9
--- /dev/null
+++ b/tests/structs/gtype-base-struct.vala
@@ -0,0 +1,47 @@
+struct foo_int : int {}
+struct foo_uint : uint {}
+struct foo_int64 : int64 {}
+struct foo_uint64 : uint64 {}
+struct foo_long : long {}
+struct foo_ulong : ulong {}
+struct foo_bool : bool {}
+struct foo_char : char {}
+struct foo_uchar : uchar {}
+struct foo_float : float {}
+struct foo_double : double {}
+struct foo_gtype : GLib.Type {}
+
+class Foo : Object {
+       public foo_int prop_int { get; set; }
+       public foo_uint prop_uint { get; set; }
+       public foo_int64 prop_int64 { get; set; }
+       public foo_uint64 prop_uint64 { get; set; }
+       public foo_long prop_long { get; set; }
+       public foo_ulong prop_ulong { get; set; }
+       public foo_bool prop_bool { get; set; }
+       public foo_char prop_char { get; set; }
+       public foo_uchar prop_uchar { get; set; }
+       public foo_float prop_float { get; set; }
+       public foo_double prop_double { get; set; }
+       public foo_gtype prop_gtype { get; set; }
+}
+
+void main () {
+       {
+               assert (typeof (foo_int) == GLib.Type.INT);
+               assert (typeof (foo_uint) == GLib.Type.UINT);
+               assert (typeof (foo_int64) == GLib.Type.INT64);
+               assert (typeof (foo_uint64) == GLib.Type.UINT64);
+               assert (typeof (foo_long) == GLib.Type.LONG);
+               assert (typeof (foo_ulong) == GLib.Type.ULONG);
+               assert (typeof (foo_bool) == GLib.Type.BOOLEAN);
+               assert (typeof (foo_char) == GLib.Type.CHAR);
+               assert (typeof (foo_uchar) == GLib.Type.UCHAR);
+               assert (typeof (foo_float) == GLib.Type.FLOAT);
+               assert (typeof (foo_double) == GLib.Type.DOUBLE);
+               assert (typeof (foo_gtype) == typeof (GLib.Type));
+       }
+       {
+               var foo = new Foo ();
+       }
+}