vala: Non nullable enum types are simple types

Fixes a regression of 5b6345a6386b05aaf3f11cb3572940413eb878a8

3 files changed, 287 insertions, 6 deletions

diff --git a/tests/enums/bug666035.c-expected b/tests/enums/bug666035.c-expected
index 558677334..07da7d02c 100644
--- a/tests/enums/bug666035.c-expected
+++ b/tests/enums/bug666035.c-expected
@@ -176,9 +176,7 @@ _vala_main (void)
 	FooStruct foo_struct = {0};
 	FooStruct _tmp4_ = {0};
 	FooStruct _tmp5_;
-	FooEnum _tmp6_;
 	FooEnum foo_enum = 0;
-	FooEnum _tmp7_;
 	if (takes_enum (FOO_ENUM_BAR) == FOO_ENUM_BAR) {
 		return;
 	}
@@ -202,11 +200,9 @@ _vala_main (void)
 	_tmp4_.f = FOO_ENUM_BAR;
 	foo_struct = _tmp4_;
 	_tmp5_ = foo_struct;
-	_tmp6_ = _tmp5_.f;
-	_vala_assert (_tmp6_ == FOO_ENUM_BAR, "foo_struct.f == BAR");
+	_vala_assert (_tmp5_.f == FOO_ENUM_BAR, "foo_struct.f == BAR");
 	foo_enum = FOO_ENUM_BAR;
-	_tmp7_ = foo_enum;
-	switch (_tmp7_) {
+	switch (foo_enum) {
 		default:
 		case FOO_ENUM_FOO:
 		{
diff --git a/tests/enums/enum-boxed.c-expected b/tests/enums/enum-boxed.c-expected
new file mode 100644
index 000000000..61def93cd
--- /dev/null
+++ b/tests/enums/enum-boxed.c-expected
@@ -0,0 +1,246 @@
+/* enums_enum_boxed.c generated by valac, the Vala compiler
+ * generated from enums_enum_boxed.vala, do not modify */
+
+#include <glib-object.h>
+#include <glib.h>
+#include <string.h>
+
+#define FOO FOO_BAR
+#define BAR BAR_FOO
+#if !defined(VALA_EXTERN)
+#if defined(_MSC_VER)
+#define VALA_EXTERN __declspec(dllexport) extern
+#elif __GNUC__ >= 4
+#define VALA_EXTERN __attribute__((visibility("default"))) extern
+#else
+#define VALA_EXTERN extern
+#endif
+#endif
+
+typedef enum  {
+	FOO_BAR = 23
+} Foo;
+
+#define TYPE_FOO (foo_get_type ())
+typedef enum  {
+	BAR_FOO = 42
+} Bar;
+
+#define TYPE_BAR (bar_get_type ())
+#define _g_free0(var) ((var == NULL) ? NULL : (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 GType foo_get_type (void) G_GNUC_CONST ;
+VALA_EXTERN GType bar_get_type (void) G_GNUC_CONST ;
+static void _vala_main (void);
+static Foo* _foo_dup (Foo* self);
+static gboolean _foo_equal (const Foo * s1,
+                     const Foo * s2);
+static Bar* _bar_dup (Bar* self);
+static gboolean _bar_equal (const Bar * s1,
+                     const Bar * s2);
+
+static GType
+foo_get_type_once (void)
+{
+	static const GEnumValue values[] = {{FOO_BAR, "FOO_BAR", "bar"}, {0, NULL, NULL}};
+	GType foo_type_id;
+	foo_type_id = g_enum_register_static ("Foo", values);
+	return foo_type_id;
+}
+
+GType
+foo_get_type (void)
+{
+	static volatile gsize foo_type_id__volatile = 0;
+	if (g_once_init_enter (&foo_type_id__volatile)) {
+		GType foo_type_id;
+		foo_type_id = foo_get_type_once ();
+		g_once_init_leave (&foo_type_id__volatile, foo_type_id);
+	}
+	return foo_type_id__volatile;
+}
+
+static GType
+bar_get_type_once (void)
+{
+	static const GFlagsValue values[] = {{BAR_FOO, "BAR_FOO", "foo"}, {0, NULL, NULL}};
+	GType bar_type_id;
+	bar_type_id = g_flags_register_static ("Bar", values);
+	return bar_type_id;
+}
+
+GType
+bar_get_type (void)
+{
+	static volatile gsize bar_type_id__volatile = 0;
+	if (g_once_init_enter (&bar_type_id__volatile)) {
+		GType bar_type_id;
+		bar_type_id = bar_get_type_once ();
+		g_once_init_leave (&bar_type_id__volatile, bar_type_id);
+	}
+	return bar_type_id__volatile;
+}
+
+static Foo*
+_foo_dup (Foo* self)
+{
+	Foo* dup;
+	dup = g_new0 (Foo, 1);
+	memcpy (dup, self, sizeof (Foo));
+	return dup;
+}
+
+static gpointer
+__foo_dup0 (gpointer self)
+{
+	return self ? _foo_dup (self) : NULL;
+}
+
+static gboolean
+_foo_equal (const Foo * s1,
+            const Foo * s2)
+{
+	if (s1 == s2) {
+		return TRUE;
+	}
+	if (s1 == NULL) {
+		return FALSE;
+	}
+	if (s2 == NULL) {
+		return FALSE;
+	}
+	return (*s1) == (*s2);
+}
+
+static Bar*
+_bar_dup (Bar* self)
+{
+	Bar* dup;
+	dup = g_new0 (Bar, 1);
+	memcpy (dup, self, sizeof (Bar));
+	return dup;
+}
+
+static gpointer
+__bar_dup0 (gpointer self)
+{
+	return self ? _bar_dup (self) : NULL;
+}
+
+static gboolean
+_bar_equal (const Bar * s1,
+            const Bar * s2)
+{
+	if (s1 == s2) {
+		return TRUE;
+	}
+	if (s1 == NULL) {
+		return FALSE;
+	}
+	if (s2 == NULL) {
+		return FALSE;
+	}
+	return (*s1) == (*s2);
+}
+
+static void
+_vala_main (void)
+{
+	{
+		Foo* foo = NULL;
+		Foo _tmp0_;
+		Foo* _tmp1_;
+		Foo _tmp2_;
+		_tmp0_ = FOO_BAR;
+		_tmp1_ = __foo_dup0 (&_tmp0_);
+		foo = _tmp1_;
+		_tmp2_ = 23;
+		_vala_assert (_foo_equal (foo, &_tmp2_) == TRUE, "foo == 23");
+		_g_free0 (foo);
+	}
+	{
+		Foo* foo = NULL;
+		Foo _tmp3_;
+		Foo* _tmp4_;
+		Foo _tmp5_;
+		_tmp3_ = FOO;
+		_tmp4_ = __foo_dup0 (&_tmp3_);
+		foo = _tmp4_;
+		_tmp5_ = 23;
+		_vala_assert (_foo_equal (foo, &_tmp5_) == TRUE, "foo == 23");
+		_g_free0 (foo);
+	}
+	{
+		Foo* _tmp6_ = NULL;
+		Foo _tmp7_;
+		Foo* _tmp8_;
+		Foo* foo = NULL;
+		Foo* _tmp9_;
+		Foo _tmp10_;
+		_tmp7_ = FOO;
+		_tmp8_ = __foo_dup0 (&_tmp7_);
+		_tmp6_ = _tmp8_;
+		_tmp9_ = _tmp6_;
+		_tmp6_ = NULL;
+		foo = _tmp9_;
+		_tmp10_ = 23;
+		_vala_assert (_foo_equal (foo, &_tmp10_) == TRUE, "foo == 23");
+		_g_free0 (foo);
+		_g_free0 (_tmp6_);
+	}
+	{
+		Bar* bar = NULL;
+		Bar _tmp11_;
+		Bar* _tmp12_;
+		Bar _tmp13_;
+		_tmp11_ = BAR_FOO;
+		_tmp12_ = __bar_dup0 (&_tmp11_);
+		bar = _tmp12_;
+		_tmp13_ = 42;
+		_vala_assert (_bar_equal (bar, &_tmp13_) == TRUE, "bar == 42");
+		_g_free0 (bar);
+	}
+	{
+		Bar* bar = NULL;
+		Bar _tmp14_;
+		Bar* _tmp15_;
+		Bar _tmp16_;
+		_tmp14_ = BAR;
+		_tmp15_ = __bar_dup0 (&_tmp14_);
+		bar = _tmp15_;
+		_tmp16_ = 42;
+		_vala_assert (_bar_equal (bar, &_tmp16_) == TRUE, "bar == 42");
+		_g_free0 (bar);
+	}
+	{
+		Bar* _tmp17_ = NULL;
+		Bar _tmp18_;
+		Bar* _tmp19_;
+		Bar* bar = NULL;
+		Bar* _tmp20_;
+		Bar _tmp21_;
+		_tmp18_ = BAR;
+		_tmp19_ = __bar_dup0 (&_tmp18_);
+		_tmp17_ = _tmp19_;
+		_tmp20_ = _tmp17_;
+		_tmp17_ = NULL;
+		bar = _tmp20_;
+		_tmp21_ = 42;
+		_vala_assert (_bar_equal (bar, &_tmp21_) == TRUE, "bar == 42");
+		_g_free0 (bar);
+		_g_free0 (_tmp17_);
+	}
+}
+
+int
+main (int argc,
+      char ** argv)
+{
+	_vala_main ();
+	return 0;
+}
+
diff --git a/tests/enums/enum-boxed.vala b/tests/enums/enum-boxed.vala
new file mode 100644
index 000000000..75c1ceaa6
--- /dev/null
+++ b/tests/enums/enum-boxed.vala
@@ -0,0 +1,39 @@
+enum Foo {
+	BAR = 23
+}
+
+const Foo FOO = Foo.BAR;
+
+[Flags]
+enum Bar {
+	FOO = 42
+}
+
+const Bar BAR = Bar.FOO;
+
+void main () {
+	{
+		Foo? foo = Foo.BAR;
+		assert (foo == 23);
+	}
+	{
+		Foo? foo = FOO;
+		assert (foo == 23);
+	}
+	{
+		var foo = (Foo?) FOO;
+		assert (foo == 23);
+	}
+	{
+		Bar? bar = Bar.FOO;
+		assert (bar == 42);
+	}
+	{
+		Bar? bar = BAR;
+		assert (bar == 42);
+	}
+	{
+		var bar = (Bar?) BAR;
+		assert (bar == 42);
+	}
+}