[vala/wip/issue/767: 3/3] codegen: Implement silent-cast for basic typed variants

[Rico Tzschichholz <ricotz src gnome org>]

commit d6040962718ec81224ab131478cd85ef4bf0c7db
Author: Rico Tzschichholz <ricotz ubuntu com>
Date:   Thu Mar 21 11:38:28 2019 +0100

    codegen: Implement silent-cast for basic typed variants
    
    Fixes https://gitlab.gnome.org/GNOME/vala/issues/767

 codegen/valagvariantmodule.vala                | 23 ++++++++++++++++++-
 tests/Makefile.am                              |  2 ++
 tests/basic-types/gvariants-unboxing-safe.vala | 31 ++++++++++++++++++++++++++
 tests/semantic/cast-gvariant-unsupported.test  |  6 +++++
 vala/valacastexpression.vala                   |  3 +++
 vala/valasemanticanalyzer.vala                 |  5 +++++
 6 files changed, 69 insertions(+), 1 deletion(-)
---
diff --git a/codegen/valagvariantmodule.vala b/codegen/valagvariantmodule.vala
index edd98b702..223302aa0 100644
--- a/codegen/valagvariantmodule.vala
+++ b/codegen/valagvariantmodule.vala
@@ -164,7 +164,28 @@ public class Vala.GVariantModule : GAsyncModule {
                if (target_type.is_real_non_null_struct_type ()) {
                        ccode.add_assignment (new CCodeIdentifier ("*result"), func_result);
                } else {
-                       ccode.add_return (func_result);
+                       if (expr.is_silent_cast && SemanticAnalyzer.is_gvariant_basic_type (target_type)) {
+                               var ccheck = new CCodeFunctionCall (new CCodeIdentifier 
("g_variant_is_of_type"));
+                               ccheck.add_argument (new CCodeIdentifier ("value"));
+                               BasicTypeInfo basic_type;
+                               get_basic_type_info (target_type.get_type_signature (), out basic_type);
+                               ccheck.add_argument (new CCodeIdentifier ("G_VARIANT_TYPE_" + 
basic_type.type_name.ascii_up ()));
+                               ccode.open_if (ccheck);
+                               if (basic_type.is_string) {
+                                       ccode.add_return (func_result);
+                               } else {
+                                       var temp_type = expr.target_type.copy ();
+                                       temp_type.nullable = false;
+                                       var temp_value = create_temp_value (temp_type, false, expr);
+                                       store_value (temp_value, new GLibValue (temp_type, func_result), 
expr.source_reference);
+                                       ccode.add_return (get_cvalue_ (transform_value (temp_value, 
expr.target_type, expr)));
+                               }
+                               ccode.add_else ();
+                               ccode.add_return (new CCodeConstant ("NULL"));
+                               ccode.close ();
+                       } else {
+                               ccode.add_return (func_result);
+                       }
                }
 
                pop_function ();
diff --git a/tests/Makefile.am b/tests/Makefile.am
index e6ec53941..a341faaea 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -34,6 +34,7 @@ TESTS = \
        basic-types/glists.vala \
        basic-types/gptrarray.vala \
        basic-types/gvariants.vala \
+       basic-types/gvariants-unboxing-safe.vala \
        basic-types/bug570846.test \
        basic-types/bug571486.vala \
        basic-types/bug591552.vala \
@@ -584,6 +585,7 @@ TESTS = \
        semantic/assignment-same-variable.vala \
        semantic/assignment-signal-incompatible-method.test \
        semantic/assignment-signal-incompatible-type.test \
+       semantic/cast-gvariant-unsupported.test \
        semantic/chainup-gobject-incompatible-type-property.test \
        semantic/chainup-gobject-unknown-property.test \
        semantic/chainup-gobject-unsupported-type-property.test \
diff --git a/tests/basic-types/gvariants-unboxing-safe.vala b/tests/basic-types/gvariants-unboxing-safe.vala
new file mode 100644
index 000000000..55e4eca45
--- /dev/null
+++ b/tests/basic-types/gvariants-unboxing-safe.vala
@@ -0,0 +1,31 @@
+void main () {
+       Variant v;
+
+       v = new Variant.int32 (4711);
+       {
+               bool? b = v as bool;
+               assert (b == null);
+       }
+       {
+               int16? i16 = v as int16;
+               assert (i16 == null);
+       }
+       {
+               int32? i32 = v as int32;
+               assert (i32 == 4711);
+       }
+       {
+               string? s = v as string;
+               assert (s == null);
+       }
+
+       v = new Variant.boolean (true);
+       {
+               bool? b = v as bool;
+               assert (b == true);
+       }
+       {
+               int32? i32 = v as int32;
+               assert (i32 == null);
+       }
+}
diff --git a/tests/semantic/cast-gvariant-unsupported.test b/tests/semantic/cast-gvariant-unsupported.test
new file mode 100644
index 000000000..80abaac67
--- /dev/null
+++ b/tests/semantic/cast-gvariant-unsupported.test
@@ -0,0 +1,6 @@
+Invalid Code
+
+void main () {
+       Variant? v = null;
+       string[]? array = v as string[];
+}
diff --git a/vala/valacastexpression.vala b/vala/valacastexpression.vala
index 1dc357764..e1a4dc7ab 100644
--- a/vala/valacastexpression.vala
+++ b/vala/valacastexpression.vala
@@ -184,6 +184,9 @@ public class Vala.CastExpression : Expression {
                    && is_gvariant (context, inner.value_type) && !is_gvariant (context, value_type)) {
                        // GVariant unboxing returns owned value
                        value_type.value_owned = true;
+                       if (is_silent_cast && !SemanticAnalyzer.is_gvariant_basic_type (value_type)) {
+                               Report.error (source_reference, "Silent casts of `GLib.Variant' is only 
supported for basic types");
+                       }
                }
 
                inner.target_type = inner.value_type.copy ();
diff --git a/vala/valasemanticanalyzer.vala b/vala/valasemanticanalyzer.vala
index 485ab222d..65bce9014 100644
--- a/vala/valasemanticanalyzer.vala
+++ b/vala/valasemanticanalyzer.vala
@@ -747,6 +747,11 @@ public class Vala.SemanticAnalyzer : CodeVisitor {
                return true;
        }
 
+       public static bool is_gvariant_basic_type (DataType type) {
+               const string[] GVARIANT_BASIC_TYPES = { "y", "b", "n", "q", "i", "u", "x", "t", "d", "s", 
"o", "g" };
+               return type.get_type_signature () in GVARIANT_BASIC_TYPES;
+       }
+
        private static DataType? get_instance_base_type (DataType instance_type, DataType base_type, CodeNode 
node_reference) {
                // construct a new type reference for the base type with correctly linked type arguments
                DataType instance_base_type;