Fix memory management when using owned variables as argument for unowned

2008-06-01  Jürg Billeter  <j@bitron.ch>

	* gobject/valaccodeinvocationexpressionbinding.vala:

	Fix memory management when using owned variables as argument
	for unowned reference and output parameters

	* tests/classes-methods.vala:

	Test owned and unowned variables as argument for reference and
	output parameters

svn path=/trunk/; revision=1527

diff --git a/ChangeLog b/ChangeLog
index d01abb1546686cf2516a75bd0f79ff02b8743f31..13c4f16f52a1e98546539846cf4f85b9156364cc 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,15 @@
+2008-06-01  Jürg Billeter  <j@bitron.ch>
+
+       * gobject/valaccodeinvocationexpressionbinding.vala:
+
+       Fix memory management when using owned variables as argument
+       for unowned reference and output parameters
+
+       * tests/classes-methods.vala:
+
+       Test owned and unowned variables as argument for reference and
+       output parameters
+
 2008-06-01  Jürg Billeter  <j@bitron.ch>
 
        * vala/valasemanticanalyzer.vala:

diff --git a/gobject/valaccodeinvocationexpressionbinding.vala b/gobject/valaccodeinvocationexpressionbinding.vala
index 189ca7482d4c99cfafe2fb54c109e65ec7acd91a..1d52c6389ee4d28c3cc9e432ac559ddb6ab2c2fd 100644 (file)
--- a/gobject/valaccodeinvocationexpressionbinding.vala
+++ b/gobject/valaccodeinvocationexpressionbinding.vala
@@ -222,19 +222,27 @@ public class Vala.CCodeInvocationExpressionBinding : CCodeExpressionBinding {
                                                ccall_expr = ccomma;
                                        }
 
-                                       // unref old value for non-null non-weak out arguments
+                                       // unref old value for non-null non-weak ref/out arguments
                                        // disabled for arrays for now as that requires special handling
-                                       if (param.direction == ParameterDirection.OUT && codegen.requires_destroy (param.parameter_type)
-                                           && !(arg.value_type is NullType || param.parameter_type is ArrayType)) {
+                                       // (ret_tmp = call (&tmp), var1 = (assign_tmp = dup (tmp), free (var1), assign_tmp), ret_tmp)
+                                       if (param.direction != ParameterDirection.IN && codegen.requires_destroy (arg.value_type)
+                                           && (param.direction == ParameterDirection.OUT || !param.parameter_type.value_owned)
+                                           && !(param.parameter_type is ArrayType)) {
                                                var unary = (UnaryExpression) arg;
 
-                                               // (ret_tmp = call (&tmp), free (var1), var1 = tmp, ret_tmp)
                                                var ccomma = new CCodeCommaExpression ();
 
-                                               var temp_var = codegen.get_temp_variable (unary.inner.value_type);
+                                               var temp_var = codegen.get_temp_variable (param.parameter_type, param.parameter_type.value_owned);
                                                codegen.temp_vars.insert (0, temp_var);
                                                cexpr = new CCodeUnaryExpression (CCodeUnaryOperator.ADDRESS_OF, new CCodeIdentifier (temp_var.name));
 
+                                               if (param.direction == ParameterDirection.REF) {
+                                                       var crefcomma = new CCodeCommaExpression ();
+                                                       crefcomma.append_expression (new CCodeAssignment (new CCodeIdentifier (temp_var.name), (CCodeExpression) unary.inner.ccodenode));
+                                                       crefcomma.append_expression (cexpr);
+                                                       cexpr = crefcomma;
+                                               }
+
                                                // call function
                                                LocalVariable ret_temp_var;
                                                if (m.return_type is VoidType) {
@@ -245,11 +253,20 @@ public class Vala.CCodeInvocationExpressionBinding : CCodeExpressionBinding {
                                                        ccomma.append_expression (new CCodeAssignment (new CCodeIdentifier (ret_temp_var.name), ccall_expr));
                                                }
 
+                                               var cassign_comma = new CCodeCommaExpression ();
+
+                                               var assign_temp_var = codegen.get_temp_variable (unary.inner.value_type, unary.inner.value_type.value_owned);
+                                               codegen.temp_vars.insert (0, assign_temp_var);
+
+                                               cassign_comma.append_expression (new CCodeAssignment (new CCodeIdentifier (assign_temp_var.name), codegen.transform_expression (new CCodeIdentifier (temp_var.name), param.parameter_type, unary.inner.value_type, arg)));
+
                                                // unref old value
-                                               ccomma.append_expression (codegen.get_unref_expression ((CCodeExpression) unary.inner.ccodenode, arg.value_type, arg));
+                                               cassign_comma.append_expression (codegen.get_unref_expression ((CCodeExpression) unary.inner.ccodenode, arg.value_type, arg));
+
+                                               cassign_comma.append_expression (new CCodeIdentifier (assign_temp_var.name));
 
                                                // assign new value
-                                               ccomma.append_expression (new CCodeAssignment ((CCodeExpression) unary.inner.ccodenode, new CCodeIdentifier (temp_var.name)));
+                                               ccomma.append_expression (new CCodeAssignment ((CCodeExpression) unary.inner.ccodenode, cassign_comma));
 
                                                // return value
                                                if (!(m.return_type is VoidType)) {

diff --git a/tests/classes-methods.vala b/tests/classes-methods.vala
index a0d6483097231a94fe477846eae05fd97cc81541..e3854d08220a545c9a70ac0e8e764a9875e2b3e2 100644 (file)
--- a/tests/classes-methods.vala
+++ b/tests/classes-methods.vala
@@ -60,6 +60,27 @@ class Maman.SubBar : Bar {
 
                BaseAccess.test ();
 
+               string str, str2;
+               weak string weak_str;
+
+               test_out (out str);
+               assert (str == "hello");
+
+               test_out_weak (out weak_str);
+               assert (weak_str == "hello");
+
+               test_out_weak (out str2);
+               assert (str == "hello");
+
+               test_ref (ref str);
+               assert (str == "world");
+
+               test_ref_weak (ref weak_str);
+               assert (str == "world");
+
+               test_ref_weak (ref str2);
+               assert (str == "world");
+
                return 0;
        }
 }
@@ -144,3 +165,21 @@ namespace Maman.BaseAccess {
        }
 }
 
+void test_out (out string bar) {
+       bar = "hello";
+}
+
+void test_out_weak (out weak string bar) {
+       bar = "hello";
+}
+
+void test_ref (ref string bar) {
+       assert (bar == "hello");
+       bar = "world";
+}
+
+void test_ref_weak (ref weak string bar) {
+       assert (bar == "hello");
+       bar = "world";
+}
+