generics/constructor-chain-up.vala \
generics/delegate-return-type-missing.test \
generics/floating-type-cast.vala \
+ generics/foreach-iterator-nullable.vala \
generics/gvariant-serialization.test \
generics/inference-argument-may-fail.vala \
generics/inference-static-function.vala \
nullability/array-element-class.vala \
nullability/array-element-string.vala \
nullability/bug611223.vala \
+ nullability/generics-invalid.test \
+ nullability/generics.vala \
nullability/local-variable-invalid-convert.test \
nullability/member-access-narrowed-instance.vala \
nullability/member-access-nullable-instance.test \
--- /dev/null
+/* generics_foreach_iterator_nullable.c generated by valac, the Vala compiler
+ * generated from generics_foreach_iterator_nullable.vala, do not modify */
+
+#include <glib.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define _g_hash_table_unref0(var) ((var == NULL) ? NULL : (var = (g_hash_table_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);
+
+static void _vala_main (void);
+static void _g_free0_ (gpointer var);
+
+static void
+_g_free0_ (gpointer var)
+{
+ var = (g_free (var), NULL);
+}
+
+static gconstpointer
+_vala_hash_set_next_value (GHashTableIter *self)
+{
+ void* vi = NULL;
+ GHashTableIter* htp = NULL;
+ void* _tmp0_;
+ gconstpointer value = NULL;
+ gconstpointer _tmp1_ = NULL;
+ gconstpointer _tmp2_ = NULL;
+ gboolean _tmp3_;
+ gconstpointer result;
+ vi = &(*self);
+ _tmp0_ = vi;
+ htp = _tmp0_;
+ _tmp3_ = g_hash_table_iter_next (htp, (gpointer*) (&_tmp2_), (gpointer*) NULL);
+ value = _tmp2_;
+ if (_tmp3_) {
+ gconstpointer _tmp4_;
+ _tmp4_ = value;
+ _tmp1_ = _tmp4_;
+ } else {
+ _tmp1_ = NULL;
+ }
+ result = _tmp1_;
+ return result;
+}
+
+static void
+_vala_main (void)
+{
+ GHashTable* gs = NULL;
+ GHashFunc _tmp0_;
+ GEqualFunc _tmp1_;
+ GHashTable* _tmp2_;
+ GHashTable* _tmp3_;
+ gchar* _tmp4_;
+ _tmp0_ = g_str_hash;
+ _tmp1_ = g_str_equal;
+ _tmp2_ = g_hash_table_new_full (_tmp0_, _tmp1_, NULL, _g_free0_);
+ gs = _tmp2_;
+ _tmp3_ = gs;
+ _tmp4_ = g_strdup ("foo");
+ g_hash_table_add (_tmp3_, _tmp4_);
+ {
+ GHashTableIter _s_it = {0};
+ GHashTable* _tmp5_;
+ GHashTableIter _tmp6_ = {0};
+ const gchar* s = NULL;
+ _tmp5_ = gs;
+ g_hash_table_iter_init (&_tmp6_, _tmp5_);
+ _s_it = _tmp6_;
+ while (TRUE) {
+ gconstpointer _tmp7_;
+ const gchar* _tmp8_;
+ const gchar* _tmp9_;
+ _tmp7_ = _vala_hash_set_next_value (&_s_it);
+ s = (const gchar*) _tmp7_;
+ _tmp8_ = s;
+ if (!(_tmp8_ != NULL)) {
+ break;
+ }
+ _tmp9_ = s;
+ _vala_assert (g_strcmp0 (_tmp9_, "foo") == 0, "s == \"foo\"");
+ }
+ }
+ _g_hash_table_unref0 (gs);
+}
+
+int
+main (int argc,
+ char ** argv)
+{
+ _vala_main ();
+ return 0;
+}
+
--- /dev/null
+void main () {
+ var gs = new GenericSet<string> (GLib.str_hash, GLib.str_equal);
+ gs.add ("foo");
+ foreach (var s in gs) {
+ assert (s == "foo");
+ }
+}
<parameter name="t_destroy_func" transfer-ownership="none">
<type name="GLib.DestroyNotify" c:type="GDestroyNotify"/>
</parameter>
- <parameter name="g" transfer-ownership="none" nullable="1">
+ <parameter name="g" transfer-ownership="none">
<type name="gpointer" c:type="gpointer"/>
</parameter>
<parameter name="t" transfer-ownership="none" nullable="1">
public delegate bool DelegateErrorTest () throws ErrorTest;
- public delegate bool DelegateGenericsTest<G,T> (G g, T t);
+ public delegate bool DelegateGenericsTest<G,T> (G g, T? t);
[GIR (visible = false)]
public delegate void SkippedDelegate ();
public GenericsTest.typed (owned DelegateGenericsTest<G,T> cb) {
}
- public void method (T param) {
+ public void method (T? param) {
}
}
[CCode (cheader_filename = "girtest.h")]
public class GenericsTest<G,T> {
public GenericsTest (owned GirTest.DelegateTest cb);
- public void method (T param);
+ public void method (T? param);
public GenericsTest.typed (owned GirTest.DelegateGenericsTest<G,T> cb);
}
[CCode (cheader_filename = "girtest.h")]
[CCode (cheader_filename = "girtest.h")]
public delegate bool DelegateErrorTest () throws GirTest.ErrorTest;
[CCode (cheader_filename = "girtest.h")]
- public delegate bool DelegateGenericsTest<G,T> (G g, T t);
+ public delegate bool DelegateGenericsTest<G,T> (G g, T? t);
[CCode (cheader_filename = "girtest.h")]
public delegate bool DelegateTest (void* a, void* b);
[CCode (cheader_filename = "girtest.h")]
--- /dev/null
+Invalid Code
+
+G? foo<G> () {
+ return null;
+}
+
+void manam<K> (K k) {
+}
+
+void bar<T> () {
+ T t = foo<T> ();
+ manam (t);
+}
+
+void main () {
+}
--- /dev/null
+/* nullability_generics.c generated by valac, the Vala compiler
+ * generated from nullability_generics.vala, do not modify */
+
+#include <glib-object.h>
+#include <glib.h>
+#include <stdlib.h>
+#include <string.h>
+
+#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 _g_free0(var) (var = (g_free (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);
+
+VALA_EXTERN gpointer foo (GType g_type,
+ GBoxedCopyFunc g_dup_func,
+ GDestroyNotify g_destroy_func);
+static void _vala_main (void);
+
+gpointer
+foo (GType g_type,
+ GBoxedCopyFunc g_dup_func,
+ GDestroyNotify g_destroy_func)
+{
+ gpointer result;
+ result = NULL;
+ return result;
+}
+
+static void
+_vala_main (void)
+{
+ gchar* s = NULL;
+ gpointer _tmp0_;
+ _tmp0_ = foo (G_TYPE_STRING, (GBoxedCopyFunc) g_strdup, (GDestroyNotify) g_free);
+ s = (gchar*) _tmp0_;
+ _vala_assert (s == NULL, "s == null");
+ _g_free0 (s);
+}
+
+int
+main (int argc,
+ char ** argv)
+{
+ _vala_main ();
+ return 0;
+}
+
--- /dev/null
+G? foo<G> () {
+ return null;
+}
+
+void main () {
+ var s = foo<string> ();
+ assert (s == null);
+}
return false;
}
if (type2.nullable != nullable) {
- return false;
+ //TODO Allow equality between nullable and non-nullable generic-types
+ // This mitigation allows fixing affected source code without breaking it.
+ // It has to be removed at some point
+ var context = CodeContext.get ();
+ return !context.experimental_non_null && this is GenericType == type2 is GenericType;
}
if (type2.type_symbol != type_symbol) {
return false;
public GenericType (TypeParameter type_parameter, SourceReference? source_reference = null) {
base.with_symbol (type_parameter, source_reference);
- // type parameters are always considered nullable
- this.nullable = true;
}
public override DataType copy () {
}
result = SemanticAnalyzer.get_actual_type (derived_instance_type, method_type_arguments, (GenericType) result, node_reference);
+ if (!result.is_non_null_simple_type ()) {
+ result.nullable = result.nullable || nullable;
+ }
return result;
}
}
public override string to_qualified_string (Scope? scope = null) {
- return type_parameter.name;
+ return "%s%s".printf (type_parameter.name, nullable ? "?" : "");
}
public override Symbol? get_member (string member_name) {
} else if (symbol_reference.error) {
//ignore previous error
error = true;
+ value_type = new InvalidType ();
return false;
}
type.source_reference = unresolved_type.source_reference;
type.value_owned = unresolved_type.value_owned;
+ type.nullable = unresolved_type.nullable;
sym.used = true;
- if (type is GenericType) {
- // type parameters are always considered nullable
- // actual type argument may or may not be nullable
- type.nullable = true;
- } else {
- type.nullable = unresolved_type.nullable;
- }
-
type.is_dynamic = unresolved_type.is_dynamic;
foreach (DataType type_arg in unresolved_type.get_type_arguments ()) {
type.add_type_argument (type_arg);
projects / thirdparty / vala.git / commitdiff
