gvariant: Simplify variant type check

Even when we don't have one of the basic types, we still have a compile-
time known type string. No need to dynamically allocate anything, just
use G_VARIANT_TYPE () to cast it into a GVariantType.

diff --git a/codegen/valagvariantmodule.vala b/codegen/valagvariantmodule.vala
index 09f345d9cd8ad11d08df66a854017657c247542f..02d106c57bafc2b522f2d7e5e04f4160bc70abc1 100644 (file)
--- a/codegen/valagvariantmodule.vala
+++ b/codegen/valagvariantmodule.vala
@@ -172,13 +172,8 @@ public class Vala.GVariantModule : GValueModule {
                        if (is_basic_type) {
                                type_expr = new CCodeIdentifier ("G_VARIANT_TYPE_" + basic_type.type_name.ascii_up ());
                        } else {
-                               var gvariant_type_type = new ObjectType ((Class) root_symbol.scope.lookup ("GLib").scope.lookup ("VariantType"));
-                               var type_temp = get_temp_variable (gvariant_type_type, true, expr, true);
-                               emit_temp_var (type_temp);
-                               type_expr = new CCodeFunctionCall (new CCodeIdentifier ("g_variant_type_new"));
-                               ((CCodeFunctionCall) type_expr).add_argument (new CCodeIdentifier ("\"%s\"".printf (signature)));
-                               store_value (get_local_cvalue (type_temp), new GLibValue (gvariant_type_type, type_expr), expr.source_reference);
-                               type_expr = get_variable_cexpression (type_temp.name);
+                               type_expr = new CCodeFunctionCall (new CCodeIdentifier ("G_VARIANT_TYPE"));
+                               ((CCodeFunctionCall) type_expr).add_argument (new CCodeConstant ("\"%s\"".printf (signature)));
                        }
                        ccheck.add_argument (type_expr);
                        ccode.open_if (new CCodeBinaryExpression (CCodeBinaryOperator.AND, new CCodeIdentifier ("value"), ccheck));
@@ -187,22 +182,8 @@ public class Vala.GVariantModule : GValueModule {
                CCodeExpression func_result = deserialize_expression (target_type, new CCodeIdentifier ("value"), new CCodeIdentifier ("*result"));
 
                if (expr.is_silent_cast) {
-                       if (is_basic_type && basic_type.is_string) {
-                               ccode.add_return (func_result);
-                       } else {
-                               if (!is_basic_type) {
-                                       var type_free = new CCodeFunctionCall (new CCodeIdentifier ("g_variant_type_free"));
-                                       type_free.add_argument (type_expr);
-                                       ccode.add_expression (type_free);
-                               }
-                               ccode.add_return (func_result);
-                       }
+                       ccode.add_return (func_result);
                        ccode.add_else ();
-                       if (!is_basic_type) {
-                               var type_free = new CCodeFunctionCall (new CCodeIdentifier ("g_variant_type_free"));
-                               type_free.add_argument (type_expr);
-                               ccode.add_expression (type_free);
-                       }
                        ccode.add_return (new CCodeConstant ("NULL"));
                        ccode.close ();
                } else if (target_type.is_real_non_null_struct_type ()) {

diff --git a/tests/basic-types/gvariants-unboxing-safe.c-expected b/tests/basic-types/gvariants-unboxing-safe.c-expected
index acad937e3c9eafacb72a07daa983ae1016ad6dda..9ed732e56b2f6303a1f91d33d4fd356a284e6a45 100644 (file)
--- a/tests/basic-types/gvariants-unboxing-safe.c-expected
+++ b/tests/basic-types/gvariants-unboxing-safe.c-expected
@@ -240,34 +240,30 @@ static gchar**
 _variant_get7 (GVariant* value,
                gint* result_length1)
 {
-       GVariantType* _tmp0_ = NULL;
-       _tmp0_ = g_variant_type_new ("as");
-       if (value && g_variant_is_of_type (value, _tmp0_)) {
-               gchar** _tmp1_;
-               gint _tmp1__length;
-               gint _tmp1__size;
-               gint _tmp1__length1;
-               GVariantIter _tmp2_;
-               GVariant* _tmp3_;
-               _tmp1_ = g_new (gchar*, 5);
-               _tmp1__length = 0;
-               _tmp1__size = 4;
-               _tmp1__length1 = 0;
-               g_variant_iter_init (&_tmp2_, value);
-               for (; (_tmp3_ = g_variant_iter_next_value (&_tmp2_)) != NULL; _tmp1__length1++) {
-                       if (_tmp1__size == _tmp1__length) {
-                               _tmp1__size = 2 * _tmp1__size;
-                               _tmp1_ = g_renew (gchar*, _tmp1_, _tmp1__size + 1);
+       if (value && g_variant_is_of_type (value, G_VARIANT_TYPE ("as"))) {
+               gchar** _tmp0_;
+               gint _tmp0__length;
+               gint _tmp0__size;
+               gint _tmp0__length1;
+               GVariantIter _tmp1_;
+               GVariant* _tmp2_;
+               _tmp0_ = g_new (gchar*, 5);
+               _tmp0__length = 0;
+               _tmp0__size = 4;
+               _tmp0__length1 = 0;
+               g_variant_iter_init (&_tmp1_, value);
+               for (; (_tmp2_ = g_variant_iter_next_value (&_tmp1_)) != NULL; _tmp0__length1++) {
+                       if (_tmp0__size == _tmp0__length) {
+                               _tmp0__size = 2 * _tmp0__size;
+                               _tmp0_ = g_renew (gchar*, _tmp0_, _tmp0__size + 1);
                        }
-                       _tmp1_[_tmp1__length++] = g_variant_dup_string (_tmp3_, NULL);
-                       g_variant_unref (_tmp3_);
+                       _tmp0_[_tmp0__length++] = g_variant_dup_string (_tmp2_, NULL);
+                       g_variant_unref (_tmp2_);
                }
-               *result_length1 = _tmp1__length1;
-               _tmp1_[_tmp1__length] = NULL;
-               g_variant_type_free (_tmp0_);
-               return _tmp1_;
+               *result_length1 = _tmp0__length1;
+               _tmp0_[_tmp0__length] = NULL;
+               return _tmp0_;
        } else {
-               g_variant_type_free (_tmp0_);
                return NULL;
        }
 }
@@ -308,28 +304,24 @@ _variant_get8 (GVariant* value,
 static Foo*
 _variant_get9 (GVariant* value)
 {
-       GVariantType* _tmp0_ = NULL;
-       _tmp0_ = g_variant_type_new ("(stb)");
-       if (value && g_variant_is_of_type (value, _tmp0_)) {
-               Foo _tmp1_;
-               GVariantIter _tmp2_;
+       if (value && g_variant_is_of_type (value, G_VARIANT_TYPE ("(stb)"))) {
+               Foo _tmp0_;
+               GVariantIter _tmp1_;
+               GVariant* _tmp2_;
                GVariant* _tmp3_;
                GVariant* _tmp4_;
-               GVariant* _tmp5_;
-               g_variant_iter_init (&_tmp2_, value);
-               _tmp3_ = g_variant_iter_next_value (&_tmp2_);
-               _tmp1_.s = g_variant_dup_string (_tmp3_, NULL);
+               g_variant_iter_init (&_tmp1_, value);
+               _tmp2_ = g_variant_iter_next_value (&_tmp1_);
+               _tmp0_.s = g_variant_dup_string (_tmp2_, NULL);
+               g_variant_unref (_tmp2_);
+               _tmp3_ = g_variant_iter_next_value (&_tmp1_);
+               _tmp0_.u64 = g_variant_get_uint64 (_tmp3_);
                g_variant_unref (_tmp3_);
-               _tmp4_ = g_variant_iter_next_value (&_tmp2_);
-               _tmp1_.u64 = g_variant_get_uint64 (_tmp4_);
+               _tmp4_ = g_variant_iter_next_value (&_tmp1_);
+               _tmp0_.b = g_variant_get_boolean (_tmp4_);
                g_variant_unref (_tmp4_);
-               _tmp5_ = g_variant_iter_next_value (&_tmp2_);
-               _tmp1_.b = g_variant_get_boolean (_tmp5_);
-               g_variant_unref (_tmp5_);
-               g_variant_type_free (_tmp0_);
-               return _vala_memdup2 (&_tmp1_, sizeof (Foo));
+               return _vala_memdup2 (&_tmp0_, sizeof (Foo));
        } else {
-               g_variant_type_free (_tmp0_);
                return NULL;
        }
 }
@@ -362,22 +354,18 @@ _variant_new2 (GHashTable* value)
 static GHashTable*
 _variant_get10 (GVariant* value)
 {
-       GVariantType* _tmp0_ = NULL;
-       _tmp0_ = g_variant_type_new ("a{ss}");
-       if (value && g_variant_is_of_type (value, _tmp0_)) {
-               GHashTable* _tmp1_;
-               GVariantIter _tmp2_;
+       if (value && g_variant_is_of_type (value, G_VARIANT_TYPE ("a{ss}"))) {
+               GHashTable* _tmp0_;
+               GVariantIter _tmp1_;
+               GVariant* _tmp2_;
                GVariant* _tmp3_;
-               GVariant* _tmp4_;
-               _tmp1_ = g_hash_table_new_full (g_str_hash, g_str_equal, (GDestroyNotify) g_free, (GDestroyNotify) g_free);
-               g_variant_iter_init (&_tmp2_, value);
-               while (g_variant_iter_loop (&_tmp2_, "{?*}", &_tmp3_, &_tmp4_)) {
-                       g_hash_table_insert (_tmp1_, g_variant_dup_string (_tmp3_, NULL), g_variant_dup_string (_tmp4_, NULL));
+               _tmp0_ = g_hash_table_new_full (g_str_hash, g_str_equal, (GDestroyNotify) g_free, (GDestroyNotify) g_free);
+               g_variant_iter_init (&_tmp1_, value);
+               while (g_variant_iter_loop (&_tmp1_, "{?*}", &_tmp2_, &_tmp3_)) {
+                       g_hash_table_insert (_tmp0_, g_variant_dup_string (_tmp2_, NULL), g_variant_dup_string (_tmp3_, NULL));
                }
-               g_variant_type_free (_tmp0_);
-               return _tmp1_;
+               return _tmp0_;
        } else {
-               g_variant_type_free (_tmp0_);
                return NULL;
        }
 }
@@ -385,22 +373,18 @@ _variant_get10 (GVariant* value)
 static GHashTable*
 _variant_get11 (GVariant* value)
 {
-       GVariantType* _tmp0_ = NULL;
-       _tmp0_ = g_variant_type_new ("a{is}");
-       if (value && g_variant_is_of_type (value, _tmp0_)) {
-               GHashTable* _tmp1_;
-               GVariantIter _tmp2_;
+       if (value && g_variant_is_of_type (value, G_VARIANT_TYPE ("a{is}"))) {
+               GHashTable* _tmp0_;
+               GVariantIter _tmp1_;
+               GVariant* _tmp2_;
                GVariant* _tmp3_;
-               GVariant* _tmp4_;
-               _tmp1_ = g_hash_table_new_full (g_direct_hash, g_direct_equal, (GDestroyNotify) NULL, (GDestroyNotify) g_free);
-               g_variant_iter_init (&_tmp2_, value);
-               while (g_variant_iter_loop (&_tmp2_, "{?*}", &_tmp3_, &_tmp4_)) {
-                       g_hash_table_insert (_tmp1_, (gpointer) ((gintptr) g_variant_get_int32 (_tmp3_)), g_variant_dup_string (_tmp4_, NULL));
+               _tmp0_ = g_hash_table_new_full (g_direct_hash, g_direct_equal, (GDestroyNotify) NULL, (GDestroyNotify) g_free);
+               g_variant_iter_init (&_tmp1_, value);
+               while (g_variant_iter_loop (&_tmp1_, "{?*}", &_tmp2_, &_tmp3_)) {
+                       g_hash_table_insert (_tmp0_, (gpointer) ((gintptr) g_variant_get_int32 (_tmp2_)), g_variant_dup_string (_tmp3_, NULL));
                }
-               g_variant_type_free (_tmp0_);
-               return _tmp1_;
+               return _tmp0_;
        } else {
-               g_variant_type_free (_tmp0_);
                return NULL;
        }
 }