From: Rico Tzschichholz Date: Mon, 7 Aug 2023 21:08:35 +0000 (+0200) Subject: vala: Infer generic type from typeof() initializer of parameters X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=dab83b728cca9f3538a98cc87b8241a327d40c15;p=thirdparty%2Fvala.git vala: Infer generic type from typeof() initializer of parameters Additionally improve inference from sizeof() initializers --- diff --git a/tests/Makefile.am b/tests/Makefile.am index f2206a219..b072ba7e6 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -815,6 +815,8 @@ TESTS = \ generics/parameter-in-cast.vala \ generics/parameter-out-cast.vala \ generics/parameter-sizeof-initializer.vala \ + generics/parameter-sizeof-initializer-2.vala \ + generics/parameter-typeof-initializer.vala \ generics/member-dup-destroy.vala \ generics/method-parameter-type-missing.test \ generics/method-parameter-unknown-type-parameter.test \ diff --git a/tests/generics/parameter-sizeof-initializer-2.c-expected b/tests/generics/parameter-sizeof-initializer-2.c-expected new file mode 100644 index 000000000..683e89da4 --- /dev/null +++ b/tests/generics/parameter-sizeof-initializer-2.c-expected @@ -0,0 +1,384 @@ +/* generics_parameter_sizeof_initializer_2.c generated by valac, the Vala compiler + * generated from generics_parameter_sizeof_initializer_2.vala, do not modify */ + +#include +#include +#include +#include +#include + +#if !defined(VALA_EXTERN) +#if defined(_WIN32) || defined(__CYGWIN__) +#define VALA_EXTERN __declspec(dllexport) extern +#elif __GNUC__ >= 4 +#define VALA_EXTERN __attribute__((visibility("default"))) extern +#else +#define VALA_EXTERN extern +#endif +#endif + +#define TYPE_FOO (foo_get_type ()) +#define FOO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_FOO, Foo)) +#define FOO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_FOO, FooClass)) +#define IS_FOO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_FOO)) +#define IS_FOO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_FOO)) +#define FOO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_FOO, FooClass)) + +typedef struct _Foo Foo; +typedef struct _FooClass FooClass; +typedef struct _FooPrivate FooPrivate; +typedef struct _ParamSpecFoo ParamSpecFoo; +#define _foo_unref0(var) ((var == NULL) ? NULL : (var = (foo_unref (var), NULL))) +#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); +#define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; } +#define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; } +#define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); + +struct _Foo { + GTypeInstance parent_instance; + volatile int ref_count; + FooPrivate * priv; +}; + +struct _FooClass { + GTypeClass parent_class; + void (*finalize) (Foo *self); +}; + +struct _FooPrivate { + GType g_type; + GBoxedCopyFunc g_dup_func; + GDestroyNotify g_destroy_func; +}; + +struct _ParamSpecFoo { + GParamSpec parent_instance; +}; + +static gint Foo_private_offset; +static gpointer foo_parent_class = NULL; + +VALA_EXTERN gpointer foo_ref (gpointer instance); +VALA_EXTERN void foo_unref (gpointer instance); +VALA_EXTERN GParamSpec* param_spec_foo (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags); +VALA_EXTERN void value_set_foo (GValue* value, + gpointer v_object); +VALA_EXTERN void value_take_foo (GValue* value, + gpointer v_object); +VALA_EXTERN gpointer value_get_foo (const GValue* value); +VALA_EXTERN GType foo_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Foo, foo_unref) +VALA_EXTERN void foo_foo (Foo* self, + gulong size); +VALA_EXTERN void foo_bar (Foo* self, + GType t_type, + GBoxedCopyFunc t_dup_func, + GDestroyNotify t_destroy_func, + gulong size); +VALA_EXTERN Foo* foo_new (GType g_type, + GBoxedCopyFunc g_dup_func, + GDestroyNotify g_destroy_func); +VALA_EXTERN Foo* foo_construct (GType object_type, + GType g_type, + GBoxedCopyFunc g_dup_func, + GDestroyNotify g_destroy_func); +static void foo_finalize (Foo * obj); +static GType foo_get_type_once (void); +VALA_EXTERN void bar (GType k_type, + GBoxedCopyFunc k_dup_func, + GDestroyNotify k_destroy_func, + gulong size); +static void _vala_main (void); + +static inline gpointer +foo_get_instance_private (Foo* self) +{ + return G_STRUCT_MEMBER_P (self, Foo_private_offset); +} + +void +foo_foo (Foo* self, + gulong size) +{ + g_return_if_fail (IS_FOO (self)); + _vala_assert (size == sizeof (guchar), "size == sizeof (uchar)"); + _vala_assert (self->priv->g_type == G_TYPE_UCHAR, "typeof (G) == Type.UCHAR"); +} + +void +foo_bar (Foo* self, + GType t_type, + GBoxedCopyFunc t_dup_func, + GDestroyNotify t_destroy_func, + gulong size) +{ + g_return_if_fail (IS_FOO (self)); + _vala_assert (size == sizeof (gchar*), "size == sizeof (string)"); + _vala_assert (t_type == G_TYPE_STRING, "typeof (T) == Type.STRING"); +} + +Foo* +foo_construct (GType object_type, + GType g_type, + GBoxedCopyFunc g_dup_func, + GDestroyNotify g_destroy_func) +{ + Foo* self = NULL; + self = (Foo*) g_type_create_instance (object_type); + self->priv->g_type = g_type; + self->priv->g_dup_func = g_dup_func; + self->priv->g_destroy_func = g_destroy_func; + return self; +} + +Foo* +foo_new (GType g_type, + GBoxedCopyFunc g_dup_func, + GDestroyNotify g_destroy_func) +{ + return foo_construct (TYPE_FOO, g_type, g_dup_func, g_destroy_func); +} + +static void +value_foo_init (GValue* value) +{ + value->data[0].v_pointer = NULL; +} + +static void +value_foo_free_value (GValue* value) +{ + if (value->data[0].v_pointer) { + foo_unref (value->data[0].v_pointer); + } +} + +static void +value_foo_copy_value (const GValue* src_value, + GValue* dest_value) +{ + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = foo_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + +static gpointer +value_foo_peek_pointer (const GValue* value) +{ + return value->data[0].v_pointer; +} + +static gchar* +value_foo_collect_value (GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + if (collect_values[0].v_pointer) { + Foo * object; + object = collect_values[0].v_pointer; + if (object->parent_instance.g_class == NULL) { + return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) { + return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } + value->data[0].v_pointer = foo_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + +static gchar* +value_foo_lcopy_value (const GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + Foo ** object_p; + object_p = collect_values[0].v_pointer; + if (!object_p) { + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + } + if (!value->data[0].v_pointer) { + *object_p = NULL; + } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) { + *object_p = value->data[0].v_pointer; + } else { + *object_p = foo_ref (value->data[0].v_pointer); + } + return NULL; +} + +GParamSpec* +param_spec_foo (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags) +{ + ParamSpecFoo* spec; + g_return_val_if_fail (g_type_is_a (object_type, TYPE_FOO), NULL); + spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags); + G_PARAM_SPEC (spec)->value_type = object_type; + return G_PARAM_SPEC (spec); +} + +gpointer +value_get_foo (const GValue* value) +{ + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_FOO), NULL); + return value->data[0].v_pointer; +} + +void +value_set_foo (GValue* value, + gpointer v_object) +{ + Foo * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_FOO)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_FOO)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + foo_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + foo_unref (old); + } +} + +void +value_take_foo (GValue* value, + gpointer v_object) +{ + Foo * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_FOO)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_FOO)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + foo_unref (old); + } +} + +static void +foo_class_init (FooClass * klass, + gpointer klass_data) +{ + foo_parent_class = g_type_class_peek_parent (klass); + ((FooClass *) klass)->finalize = foo_finalize; + g_type_class_adjust_private_offset (klass, &Foo_private_offset); +} + +static void +foo_instance_init (Foo * self, + gpointer klass) +{ + self->priv = foo_get_instance_private (self); + self->ref_count = 1; +} + +static void +foo_finalize (Foo * obj) +{ + Foo * self; + self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_FOO, Foo); + g_signal_handlers_destroy (self); +} + +static GType +foo_get_type_once (void) +{ + static const GTypeValueTable g_define_type_value_table = { value_foo_init, value_foo_free_value, value_foo_copy_value, value_foo_peek_pointer, "p", value_foo_collect_value, "p", value_foo_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (FooClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) foo_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Foo), 0, (GInstanceInitFunc) foo_instance_init, &g_define_type_value_table }; + static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }; + GType foo_type_id; + foo_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Foo", &g_define_type_info, &g_define_type_fundamental_info, 0); + Foo_private_offset = g_type_add_instance_private (foo_type_id, sizeof (FooPrivate)); + return foo_type_id; +} + +GType +foo_get_type (void) +{ + static volatile gsize foo_type_id__once = 0; + if (g_once_init_enter (&foo_type_id__once)) { + GType foo_type_id; + foo_type_id = foo_get_type_once (); + g_once_init_leave (&foo_type_id__once, foo_type_id); + } + return foo_type_id__once; +} + +gpointer +foo_ref (gpointer instance) +{ + Foo * self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + +void +foo_unref (gpointer instance) +{ + Foo * self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + FOO_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + +void +bar (GType k_type, + GBoxedCopyFunc k_dup_func, + GDestroyNotify k_destroy_func, + gulong size) +{ + _vala_assert (size == sizeof (gint), "size == sizeof (int)"); + _vala_assert (k_type == G_TYPE_INT, "typeof (K) == Type.INT"); +} + +static void +_vala_main (void) +{ + { + Foo* foo = NULL; + Foo* _tmp0_; + _tmp0_ = foo_new (G_TYPE_UCHAR, NULL, NULL); + foo = _tmp0_; + foo_foo (foo, sizeof (guchar)); + foo_bar (foo, G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, sizeof (gchar*)); + foo_bar (foo, G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free, sizeof (gchar*)); + _foo_unref0 (foo); + } + { + bar (G_TYPE_INT, NULL, NULL, sizeof (gint)); + bar (G_TYPE_INT, NULL, NULL, sizeof (gint)); + } +} + +int +main (int argc, + char ** argv) +{ + _vala_main (); + return 0; +} + diff --git a/tests/generics/parameter-sizeof-initializer-2.vala b/tests/generics/parameter-sizeof-initializer-2.vala new file mode 100644 index 000000000..2afcf7db5 --- /dev/null +++ b/tests/generics/parameter-sizeof-initializer-2.vala @@ -0,0 +1,29 @@ +class Foo { + public void foo (ulong size = sizeof (G)) { + assert (size == sizeof (uchar)); + assert (typeof (G) == Type.UCHAR); + } + + public void bar (ulong size = sizeof (T)) { + assert (size == sizeof (string)); + assert (typeof (T) == Type.STRING); + } +} + +void bar (ulong size = sizeof (K)) { + assert (size == sizeof (int)); + assert (typeof (K) == Type.INT); +} + +void main () { + { + var foo = new Foo (); + foo.foo (); + foo.bar (sizeof (string)); + foo.bar (); + } + { + bar (sizeof (int)); + bar (); + } +} diff --git a/tests/generics/parameter-typeof-initializer.c-expected b/tests/generics/parameter-typeof-initializer.c-expected new file mode 100644 index 000000000..f6f6c96f7 --- /dev/null +++ b/tests/generics/parameter-typeof-initializer.c-expected @@ -0,0 +1,381 @@ +/* generics_parameter_typeof_initializer.c generated by valac, the Vala compiler + * generated from generics_parameter_typeof_initializer.vala, do not modify */ + +#include +#include +#include +#include +#include + +#if !defined(VALA_EXTERN) +#if defined(_WIN32) || defined(__CYGWIN__) +#define VALA_EXTERN __declspec(dllexport) extern +#elif __GNUC__ >= 4 +#define VALA_EXTERN __attribute__((visibility("default"))) extern +#else +#define VALA_EXTERN extern +#endif +#endif + +#define TYPE_FOO (foo_get_type ()) +#define FOO(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TYPE_FOO, Foo)) +#define FOO_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TYPE_FOO, FooClass)) +#define IS_FOO(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TYPE_FOO)) +#define IS_FOO_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TYPE_FOO)) +#define FOO_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TYPE_FOO, FooClass)) + +typedef struct _Foo Foo; +typedef struct _FooClass FooClass; +typedef struct _FooPrivate FooPrivate; +typedef struct _ParamSpecFoo ParamSpecFoo; +#define _foo_unref0(var) ((var == NULL) ? NULL : (var = (foo_unref (var), NULL))) +#define _vala_assert(expr, msg) if G_LIKELY (expr) ; else g_assertion_message_expr (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); +#define _vala_return_if_fail(expr, msg) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return; } +#define _vala_return_val_if_fail(expr, msg, val) if G_LIKELY (expr) ; else { g_return_if_fail_warning (G_LOG_DOMAIN, G_STRFUNC, msg); return val; } +#define _vala_warn_if_fail(expr, msg) if G_LIKELY (expr) ; else g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, msg); + +struct _Foo { + GTypeInstance parent_instance; + volatile int ref_count; + FooPrivate * priv; +}; + +struct _FooClass { + GTypeClass parent_class; + void (*finalize) (Foo *self); +}; + +struct _FooPrivate { + GType g_type; + GBoxedCopyFunc g_dup_func; + GDestroyNotify g_destroy_func; +}; + +struct _ParamSpecFoo { + GParamSpec parent_instance; +}; + +static gint Foo_private_offset; +static gpointer foo_parent_class = NULL; + +VALA_EXTERN gpointer foo_ref (gpointer instance); +VALA_EXTERN void foo_unref (gpointer instance); +VALA_EXTERN GParamSpec* param_spec_foo (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags); +VALA_EXTERN void value_set_foo (GValue* value, + gpointer v_object); +VALA_EXTERN void value_take_foo (GValue* value, + gpointer v_object); +VALA_EXTERN gpointer value_get_foo (const GValue* value); +VALA_EXTERN GType foo_get_type (void) G_GNUC_CONST ; +G_DEFINE_AUTOPTR_CLEANUP_FUNC (Foo, foo_unref) +VALA_EXTERN void foo_foo (Foo* self, + GType g); +VALA_EXTERN void foo_bar (Foo* self, + GType t_type, + GBoxedCopyFunc t_dup_func, + GDestroyNotify t_destroy_func, + GType t); +VALA_EXTERN Foo* foo_new (GType g_type, + GBoxedCopyFunc g_dup_func, + GDestroyNotify g_destroy_func); +VALA_EXTERN Foo* foo_construct (GType object_type, + GType g_type, + GBoxedCopyFunc g_dup_func, + GDestroyNotify g_destroy_func); +static void foo_finalize (Foo * obj); +static GType foo_get_type_once (void); +VALA_EXTERN void bar (GType k_type, + GBoxedCopyFunc k_dup_func, + GDestroyNotify k_destroy_func, + GType k); +static void _vala_main (void); + +static inline gpointer +foo_get_instance_private (Foo* self) +{ + return G_STRUCT_MEMBER_P (self, Foo_private_offset); +} + +void +foo_foo (Foo* self, + GType g) +{ + g_return_if_fail (IS_FOO (self)); + _vala_assert (g == G_TYPE_STRING, "g == typeof (string)"); +} + +void +foo_bar (Foo* self, + GType t_type, + GBoxedCopyFunc t_dup_func, + GDestroyNotify t_destroy_func, + GType t) +{ + g_return_if_fail (IS_FOO (self)); + _vala_assert (t == G_TYPE_GTYPE, "t == typeof (Type)"); +} + +Foo* +foo_construct (GType object_type, + GType g_type, + GBoxedCopyFunc g_dup_func, + GDestroyNotify g_destroy_func) +{ + Foo* self = NULL; + self = (Foo*) g_type_create_instance (object_type); + self->priv->g_type = g_type; + self->priv->g_dup_func = g_dup_func; + self->priv->g_destroy_func = g_destroy_func; + return self; +} + +Foo* +foo_new (GType g_type, + GBoxedCopyFunc g_dup_func, + GDestroyNotify g_destroy_func) +{ + return foo_construct (TYPE_FOO, g_type, g_dup_func, g_destroy_func); +} + +static void +value_foo_init (GValue* value) +{ + value->data[0].v_pointer = NULL; +} + +static void +value_foo_free_value (GValue* value) +{ + if (value->data[0].v_pointer) { + foo_unref (value->data[0].v_pointer); + } +} + +static void +value_foo_copy_value (const GValue* src_value, + GValue* dest_value) +{ + if (src_value->data[0].v_pointer) { + dest_value->data[0].v_pointer = foo_ref (src_value->data[0].v_pointer); + } else { + dest_value->data[0].v_pointer = NULL; + } +} + +static gpointer +value_foo_peek_pointer (const GValue* value) +{ + return value->data[0].v_pointer; +} + +static gchar* +value_foo_collect_value (GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + if (collect_values[0].v_pointer) { + Foo * object; + object = collect_values[0].v_pointer; + if (object->parent_instance.g_class == NULL) { + return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) { + return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL); + } + value->data[0].v_pointer = foo_ref (object); + } else { + value->data[0].v_pointer = NULL; + } + return NULL; +} + +static gchar* +value_foo_lcopy_value (const GValue* value, + guint n_collect_values, + GTypeCValue* collect_values, + guint collect_flags) +{ + Foo ** object_p; + object_p = collect_values[0].v_pointer; + if (!object_p) { + return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); + } + if (!value->data[0].v_pointer) { + *object_p = NULL; + } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) { + *object_p = value->data[0].v_pointer; + } else { + *object_p = foo_ref (value->data[0].v_pointer); + } + return NULL; +} + +GParamSpec* +param_spec_foo (const gchar* name, + const gchar* nick, + const gchar* blurb, + GType object_type, + GParamFlags flags) +{ + ParamSpecFoo* spec; + g_return_val_if_fail (g_type_is_a (object_type, TYPE_FOO), NULL); + spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags); + G_PARAM_SPEC (spec)->value_type = object_type; + return G_PARAM_SPEC (spec); +} + +gpointer +value_get_foo (const GValue* value) +{ + g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_FOO), NULL); + return value->data[0].v_pointer; +} + +void +value_set_foo (GValue* value, + gpointer v_object) +{ + Foo * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_FOO)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_FOO)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + foo_ref (value->data[0].v_pointer); + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + foo_unref (old); + } +} + +void +value_take_foo (GValue* value, + gpointer v_object) +{ + Foo * old; + g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, TYPE_FOO)); + old = value->data[0].v_pointer; + if (v_object) { + g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, TYPE_FOO)); + g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value))); + value->data[0].v_pointer = v_object; + } else { + value->data[0].v_pointer = NULL; + } + if (old) { + foo_unref (old); + } +} + +static void +foo_class_init (FooClass * klass, + gpointer klass_data) +{ + foo_parent_class = g_type_class_peek_parent (klass); + ((FooClass *) klass)->finalize = foo_finalize; + g_type_class_adjust_private_offset (klass, &Foo_private_offset); +} + +static void +foo_instance_init (Foo * self, + gpointer klass) +{ + self->priv = foo_get_instance_private (self); + self->ref_count = 1; +} + +static void +foo_finalize (Foo * obj) +{ + Foo * self; + self = G_TYPE_CHECK_INSTANCE_CAST (obj, TYPE_FOO, Foo); + g_signal_handlers_destroy (self); +} + +static GType +foo_get_type_once (void) +{ + static const GTypeValueTable g_define_type_value_table = { value_foo_init, value_foo_free_value, value_foo_copy_value, value_foo_peek_pointer, "p", value_foo_collect_value, "p", value_foo_lcopy_value }; + static const GTypeInfo g_define_type_info = { sizeof (FooClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) foo_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (Foo), 0, (GInstanceInitFunc) foo_instance_init, &g_define_type_value_table }; + static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) }; + GType foo_type_id; + foo_type_id = g_type_register_fundamental (g_type_fundamental_next (), "Foo", &g_define_type_info, &g_define_type_fundamental_info, 0); + Foo_private_offset = g_type_add_instance_private (foo_type_id, sizeof (FooPrivate)); + return foo_type_id; +} + +GType +foo_get_type (void) +{ + static volatile gsize foo_type_id__once = 0; + if (g_once_init_enter (&foo_type_id__once)) { + GType foo_type_id; + foo_type_id = foo_get_type_once (); + g_once_init_leave (&foo_type_id__once, foo_type_id); + } + return foo_type_id__once; +} + +gpointer +foo_ref (gpointer instance) +{ + Foo * self; + self = instance; + g_atomic_int_inc (&self->ref_count); + return instance; +} + +void +foo_unref (gpointer instance) +{ + Foo * self; + self = instance; + if (g_atomic_int_dec_and_test (&self->ref_count)) { + FOO_GET_CLASS (self)->finalize (self); + g_type_free_instance ((GTypeInstance *) self); + } +} + +void +bar (GType k_type, + GBoxedCopyFunc k_dup_func, + GDestroyNotify k_destroy_func, + GType k) +{ + _vala_assert (k == TYPE_FOO, "k == typeof (Foo)"); +} + +static void +_vala_main (void) +{ + { + Foo* foo = NULL; + Foo* _tmp0_; + _tmp0_ = foo_new (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free); + foo = _tmp0_; + foo_foo (foo, G_TYPE_STRING); + foo_bar (foo, G_TYPE_GTYPE, NULL, NULL, G_TYPE_GTYPE); + foo_bar (foo, G_TYPE_GTYPE, NULL, NULL, G_TYPE_GTYPE); + _foo_unref0 (foo); + } + { + bar (TYPE_FOO, (GBoxedCopyFunc) foo_ref, (GDestroyNotify) foo_unref, TYPE_FOO); + bar (TYPE_FOO, (GBoxedCopyFunc) foo_ref, (GDestroyNotify) foo_unref, TYPE_FOO); + } +} + +int +main (int argc, + char ** argv) +{ + _vala_main (); + return 0; +} + diff --git a/tests/generics/parameter-typeof-initializer.vala b/tests/generics/parameter-typeof-initializer.vala new file mode 100644 index 000000000..ae704a8fb --- /dev/null +++ b/tests/generics/parameter-typeof-initializer.vala @@ -0,0 +1,26 @@ +class Foo { + public void foo (Type g = typeof (G)) { + assert (g == typeof (string)); + } + + public void bar (Type t = typeof (T)) { + assert (t == typeof (Type)); + } +} + +void bar (Type k = typeof (K)) { + assert (k == typeof (Foo)); +} + +void main () { + { + var foo = new Foo (); + foo.foo (); + foo.bar (typeof (Type)); + foo.bar (); + } + { + bar (typeof (Foo)); + bar (); + } +} diff --git a/vala/valamethodcall.vala b/vala/valamethodcall.vala index 8dd33750e..97fb3d7dd 100644 --- a/vala/valamethodcall.vala +++ b/vala/valamethodcall.vala @@ -590,7 +590,16 @@ public class Vala.MethodCall : Expression, CallableExpression { if (arg_it.next ()) { Expression arg = arg_it.get (); - type_arg = param.variable_type.infer_type_argument (type_param, arg.value_type); + if (param.initializer is SizeofExpression && arg is SizeofExpression + && ((SizeofExpression) param.initializer).type_reference.type_symbol == type_param) { + type_arg = ((SizeofExpression) arg).type_reference.copy (); + } else if (param.initializer is TypeofExpression && arg is TypeofExpression + && ((TypeofExpression) param.initializer).type_reference.type_symbol == type_param) { + type_arg = ((TypeofExpression) arg).type_reference.copy (); + } else { + type_arg = param.variable_type.infer_type_argument (type_param, arg.value_type); + } + if (type_arg != null) { break; } @@ -645,13 +654,18 @@ public class Vala.MethodCall : Expression, CallableExpression { return false; } - //Resolve possible generic-type in SizeofExpression used as parameter default-value + //Resolve possible generic-type in certain Expressions used as parameter default-value foreach (Expression arg in argument_list) { unowned SizeofExpression? sizeof_expr = arg as SizeofExpression; if (sizeof_expr != null && sizeof_expr.type_reference is GenericType) { var sizeof_type = sizeof_expr.type_reference.get_actual_type (target_object_type, method_type_args, this); replace_expression (arg, new SizeofExpression (sizeof_type, source_reference)); } + unowned TypeofExpression? typeof_expr = arg as TypeofExpression; + if (typeof_expr != null && typeof_expr.type_reference is GenericType) { + var typeof_type = typeof_expr.type_reference.get_actual_type (target_object_type, method_type_args, this); + replace_expression (arg, new TypeofExpression (typeof_type, source_reference)); + } } /* Check for constructv chain up */