RubyGems - gobject-introspection - Versions diffs - 3.3.8 → 3.3.9 - Mend

gobject-introspection 3.3.8 → 3.3.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (33) hide show

checksums.yaml +4 -4
data/ext/gobject-introspection/extconf.rb +4 -4
data/ext/gobject-introspection/gobject_introspection.def +2 -1
data/ext/gobject-introspection/rb-gi-arg-info.c +33 -1
data/ext/gobject-introspection/rb-gi-argument.c +384 -3291
data/ext/gobject-introspection/rb-gi-arguments-in.c +2229 -0
data/ext/gobject-introspection/rb-gi-arguments-out.c +929 -0
data/ext/gobject-introspection/rb-gi-arguments.c +850 -0
data/ext/gobject-introspection/rb-gi-array-type.c +54 -0
data/ext/gobject-introspection/rb-gi-callback.c +242 -0
data/ext/gobject-introspection/rb-gi-conversions.h +0 -43
data/ext/gobject-introspection/rb-gi-direction.c +36 -0
data/ext/gobject-introspection/rb-gi-field-info.c +172 -81
data/ext/gobject-introspection/rb-gi-function-info.c +15 -1404
data/ext/gobject-introspection/rb-gi-private-arg-info.h +24 -0
data/ext/gobject-introspection/rb-gi-private-arguments-in.h +26 -0
data/ext/gobject-introspection/rb-gi-private-arguments-out.h +28 -0
data/ext/gobject-introspection/rb-gi-private-arguments.h +107 -0
data/ext/gobject-introspection/rb-gi-private-array-type.h +26 -0
data/ext/gobject-introspection/rb-gi-private-callback.h +41 -0
data/ext/gobject-introspection/rb-gi-private-direction.h +24 -0
data/ext/gobject-introspection/rb-gi-private-transfer.h +24 -0
data/ext/gobject-introspection/rb-gi-private.h +11 -5
data/ext/gobject-introspection/rb-gi-struct-info.c +2 -0
data/ext/gobject-introspection/rb-gi-transfer.c +36 -0
data/ext/gobject-introspection/rb-gi-type-info.c +1 -13
data/ext/gobject-introspection/rb-gobject-introspection.c +4 -1
data/ext/gobject-introspection/rb-gobject-introspection.h +5 -23
data/lib/gobject-introspection/arg-info.rb +2 -0
data/lib/gobject-introspection/callable-info.rb +1 -1
data/lib/gobject-introspection/loader.rb +0 -39
data/lib/gobject-introspection/type-tag.rb +39 -2
metadata +21 -5

checksums.yaml CHANGED

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce2773caef8d28da88dd1ed2dfdf50fb20ada6db54107376328245119a7c43e1
-  data.tar.gz: e465986398c01171ea645d4e544abc2649bbffb1cd06ad00ede6ab4f903df981
+  metadata.gz: 63b8621d7aa520ba998438e4930c7d6e69398c520e589adafea823aa7597790b
+  data.tar.gz: 4b3b7409538ab5cdbcf237a1e107d25b276eaa61f4ca56cf771764e3a1343aa3
 SHA512:
-  metadata.gz: 464ce3a16ac291fe676b7dc6bb8af918aa706cb3685985309b3bdf8dad13387349ebd4f243e599e89d95151edc927720a9d7cf46a6cabafc58d13a97c46894d8
-  data.tar.gz: 671033bd5e52f2bf7792ea7d86a2797a9c437bb62cc4da1c1ce8264fbc489398e7cc22823695abe7f3c4c2d07564a82800da3c0482452430ba7bb6338ddddafb
+  metadata.gz: ddce980ec3e2abf3a95c16ceb6e48489af7cddd03d59e135485c1adfbe61263b6349ee4d0b53025df9d5ec0f6140721c2ec61604bf6dd2f9304446069e0482e1
+  data.tar.gz: dec6cddf5c698e47b511913e0f827f29fac841fffee0d3566bdda09f98aab2fd24d84534d695cf2ea6da767402afcc56b789bb9b937f49d6f345755e985b9f6f

data/ext/gobject-introspection/extconf.rb CHANGED

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 #
-# Copyright (C) 2012-2013  Ruby-GNOME2 Project Team
+# Copyright (C) 2012-2019  Ruby-GNOME Project Team
 #
 # This library is free software; you can redistribute it and/or
 # modify it under the terms of the GNU Lesser General Public
@@ -37,7 +37,7 @@ $LOAD_PATH.unshift(mkmf_gnome2_dir.to_s)
 module_name = "gobject_introspection"
 package_id = "gobject-introspection-1.0"
-require "mkmf-gnome2"
+require "mkmf-gnome"
 ["glib2"].each do |package|
   directory = "#{package}#{version_suffix}"
@@ -51,7 +51,7 @@ end
 unless required_pkg_config_package(package_id,
                                    :alt_linux => "gobject-introspection-devel",
                                    :debian => "libgirepository1.0-dev",
-                                   :redhat => "gobject-introspection-devel",
+                                   :redhat => "pkgconfig(gobject-introspection-1.0)",
                                    :homebrew => "gobject-introspection",
                                    :arch_linux => "gobject-introspection",
                                    :macports => "gobject-introspection",
@@ -73,7 +73,7 @@ end
 glib_mkenums(enum_type_prefix, headers, "G_TYPE_", ["girepository.h"])
 create_pkg_config_file("Ruby/GObjectIntrospection",
-                       package_id, ruby_gnome2_version,
+                       package_id, ruby_gnome_version,
                        "ruby-gobject-introspection.pc")
 ensure_objs

data/ext/gobject-introspection/gobject_introspection.def CHANGED

@@ -1,10 +1,11 @@
 EXPORTS
 	Init_gobject_introspection
-	rb_gi_callback_register_finder
 	rb_gi_callback_data_free
 	rb_gi_callback_data_get_metadata
 	rb_gi_callback_data_get_rb_callback
+	rb_gi_callback_register_finder
 	rb_gi_struct_new_raw
 	rb_gi_struct_get_raw

data/ext/gobject-introspection/rb-gi-arg-info.c CHANGED

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2012-2019  Ruby-GNOME Project Team
  *
  *  This library is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public
@@ -23,6 +23,29 @@
 #define RG_TARGET_NAMESPACE rb_cGIArgInfo
 #define SELF(self) (RVAL2GI_ARG_INFO(self))
+gboolean
+rb_gi_arg_info_is_output_buffer(GIArgInfo *info)
+{
+    if (g_arg_info_get_direction(info) != GI_DIRECTION_OUT) {
+        return FALSE;
+    }
+    if (!g_arg_info_is_caller_allocates(info)) {
+        return FALSE;
+    }
+    GITypeInfo type_info;
+    g_arg_info_load_type(info, &type_info);
+    if (g_type_info_get_tag(&type_info) != GI_TYPE_TAG_ARRAY) {
+        return FALSE;
+    }
+    GITypeInfo *element_type_info = g_type_info_get_param_type(&type_info, 0);
+    GITypeTag element_type_tag = g_type_info_get_tag(element_type_info);
+    g_base_info_unref(element_type_info);
+    return element_type_tag == GI_TYPE_TAG_UINT8;
+}
 GType
 gi_arg_info_get_type(void)
 {
@@ -125,6 +148,13 @@ rg_type(VALUE self)
     return GI_BASE_INFO2RVAL_WITH_UNREF(g_arg_info_get_type(info));
 }
+static VALUE
+rg_output_buffer_p(VALUE self)
+{
+    GIArgInfo *info = SELF(self);
+    return CBOOL2RVAL(rb_gi_arg_info_is_output_buffer(info));
+}
 void
 rb_gi_arg_info_init(VALUE rb_mGI, VALUE rb_cGIBaseInfo)
 {
@@ -145,6 +175,8 @@ rb_gi_arg_info_init(VALUE rb_mGI, VALUE rb_cGIBaseInfo)
     RG_DEF_METHOD(destroy, 0);
     RG_DEF_METHOD(type, 0);
+    RG_DEF_METHOD_P(output_buffer, 0);
     G_DEF_CLASS(G_TYPE_I_DIRECTION, "Direction", rb_mGI);
     G_DEF_CLASS(G_TYPE_I_SCOPE_TYPE, "ScopeType", rb_mGI);
     G_DEF_CLASS(G_TYPE_I_TRANSFER, "Transfer", rb_mGI);

data/ext/gobject-introspection/rb-gi-argument.c CHANGED

@@ -25,36 +25,6 @@ static VALUE rb_cGLibBytes = Qnil;
 static VALUE rb_cGLibObject = Qnil;
 static VALUE rb_cGLibValue = Qnil;
-static gboolean
-rb_gi_arg_info_may_be_null(GIArgInfo *arg_info)
-{
-#if GI_CHECK_VERSION(1, 42, 0)
-    return g_arg_info_may_be_null(arg_info);
-#else
-    /*
-      GObject Introspection < 1.42 doesn't support "(nullable)" yet.
-      So, we assume that all argument may be NULL. It's danger but
-      convenient.
-    */
-    return TRUE;
-#endif
-}
-static const gchar *
-rb_gi_transfer_to_string(GITransfer transfer)
-{
-    switch(transfer) {
-      case GI_TRANSFER_NOTHING:
-        return "nothing";
-      case GI_TRANSFER_CONTAINER:
-        return "container";
-      case GI_TRANSFER_EVERYTHING:
-        return "everything";
-      default:
-        return "unknown";
-    }
-}
 static void
 array_c_to_ruby_sized_interface(gconstpointer *elements,
                                 gint64 n_elements,
@@ -722,17 +692,14 @@ rb_gi_argument_to_ruby_interface(GIArgument *argument,
 static void
 normalize_out_array_length(GIArgument *normalized_argument,
                            GIArgument *argument,
-                           GITypeInfo *type_info)
+                           RBGIArgMetadata *metadata)
 {
-    GITypeTag type_tag;
-    type_tag = g_type_info_get_tag(type_info);
-    switch (type_tag) {
+    switch (metadata->type.tag) {
     case GI_TYPE_TAG_VOID:
     case GI_TYPE_TAG_BOOLEAN:
         rb_raise(rb_eNotImpError,
                  "TODO: invalid out array length argument?: <%s>",
-                 g_type_tag_to_string(type_tag));
+                 g_type_tag_to_string(metadata->type.tag));
         break;
     case GI_TYPE_TAG_INT8:
         normalized_argument->v_int8 = *((gint8 *)argument->v_pointer);
@@ -772,7 +739,7 @@ normalize_out_array_length(GIArgument *normalized_argument,
     case GI_TYPE_TAG_UNICHAR:
         rb_raise(rb_eNotImpError,
                  "TODO: invalid out array length argument?: <%s>",
-                 g_type_tag_to_string(type_tag));
+                 g_type_tag_to_string(metadata->type.tag));
         break;
     default:
         g_assert_not_reached();
@@ -791,21 +758,15 @@ rb_gi_argument_to_ruby_array(GIArgument *array_argument,
     gint length_index;
     GIArgument *length_argument = NULL;
     GIArgument normalized_length_argument;
-    GITypeInfo raw_length_type_info;
     GITypeInfo *length_type_info = NULL;
     length_index = g_type_info_get_array_length(array_type_info);
     if (length_index != -1) {
         RBGIArgMetadata *length_metadata;
-        GIArgInfo *length_arg_info = NULL;
         GIArgument *raw_length_argument = NULL;
         length_metadata = g_ptr_array_index(args_metadata, length_index);
-        length_arg_info = &(length_metadata->arg_info);
-        g_arg_info_load_type(length_arg_info, &raw_length_type_info);
-        length_type_info = &raw_length_type_info;
+        length_type_info = length_metadata->type.info;
         if (length_metadata->direction == GI_DIRECTION_OUT) {
             raw_length_argument = &g_array_index(out_args, GIArgument,
                                                  length_metadata->out_arg_index);
@@ -815,10 +776,15 @@ rb_gi_argument_to_ruby_array(GIArgument *array_argument,
         }
         if (raw_length_argument) {
-            normalize_out_array_length(&normalized_length_argument,
-                                       raw_length_argument,
-                                       length_type_info);
-            length_argument = &normalized_length_argument;
+            if (length_metadata->array_metadata &&
+                length_metadata->array_metadata->output_buffer_p) {
+                length_argument = raw_length_argument;
+            } else {
+                normalize_out_array_length(&normalized_length_argument,
+                                           raw_length_argument,
+                                           length_metadata);
+                length_argument = &normalized_length_argument;
+            }
         } else {
             length_argument = &g_array_index(in_args, GIArgument,
                                              length_metadata->in_arg_index);
@@ -1418,158 +1384,79 @@ rb_gi_argument_to_ruby(GIArgument *argument,
 }
 static void
-rb_gi_out_argument_init_array_c(GIArgument *argument,
-                                G_GNUC_UNUSED GIArgInfo *arg_info,
-                                G_GNUC_UNUSED GITypeInfo *array_type_info,
-                                GITypeInfo *element_type_info)
+rb_gi_return_argument_free_container(GIArgument *argument,
+                                     GITypeInfo *type_info)
 {
-    GITypeTag element_type_tag;
+    GITypeTag type_tag;
-    element_type_tag = g_type_info_get_tag(element_type_info);
+    type_tag = g_type_info_get_tag(type_info);
-    switch (element_type_tag) {
-      case GI_TYPE_TAG_VOID:
-      case GI_TYPE_TAG_BOOLEAN:
-      case GI_TYPE_TAG_INT8:
-        g_base_info_unref(element_type_info);
-        rb_raise(rb_eNotImpError,
-                 "TODO: allocates GIArgument(array)[c][%s] for output",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-      case GI_TYPE_TAG_UINT8:
-        argument->v_pointer = xmalloc(sizeof(guint8 *));
-        break;
-      case GI_TYPE_TAG_INT16:
-      case GI_TYPE_TAG_UINT16:
-      case GI_TYPE_TAG_INT32:
-      case GI_TYPE_TAG_UINT32:
-      case GI_TYPE_TAG_INT64:
-      case GI_TYPE_TAG_UINT64:
-      case GI_TYPE_TAG_FLOAT:
-      case GI_TYPE_TAG_DOUBLE:
-      case GI_TYPE_TAG_GTYPE:
-        g_base_info_unref(element_type_info);
-        rb_raise(rb_eNotImpError,
-                 "TODO: allocates GIArgument(array)[c][%s] for output",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-      case GI_TYPE_TAG_UTF8:
-        argument->v_pointer = xmalloc(sizeof(gchar **));
-        break;
-      case GI_TYPE_TAG_FILENAME:
-      case GI_TYPE_TAG_ARRAY:
-        g_base_info_unref(element_type_info);
+    switch (type_tag) {
+    case GI_TYPE_TAG_VOID:
+    case GI_TYPE_TAG_BOOLEAN:
+    case GI_TYPE_TAG_INT8:
+    case GI_TYPE_TAG_UINT8:
+    case GI_TYPE_TAG_INT16:
+    case GI_TYPE_TAG_UINT16:
+    case GI_TYPE_TAG_INT32:
+    case GI_TYPE_TAG_UINT32:
+    case GI_TYPE_TAG_INT64:
+    case GI_TYPE_TAG_UINT64:
+    case GI_TYPE_TAG_FLOAT:
+    case GI_TYPE_TAG_DOUBLE:
+    case GI_TYPE_TAG_GTYPE:
+    case GI_TYPE_TAG_UTF8:
+    case GI_TYPE_TAG_FILENAME:
         rb_raise(rb_eNotImpError,
-                 "TODO: allocates GIArgument(array)[c][%s] for output",
-                 g_type_tag_to_string(element_type_tag));
+                 "TODO: free GIArgument(%s) as container",
+                 g_type_tag_to_string(type_tag));
         break;
-      case GI_TYPE_TAG_INTERFACE:
-        argument->v_pointer = xmalloc(sizeof(gpointer *));
+    case GI_TYPE_TAG_ARRAY:
+        g_free(argument->v_pointer);
         break;
-      case GI_TYPE_TAG_GLIST:
-      case GI_TYPE_TAG_GSLIST:
-      case GI_TYPE_TAG_GHASH:
-      case GI_TYPE_TAG_ERROR:
-      case GI_TYPE_TAG_UNICHAR:
-        g_base_info_unref(element_type_info);
+    case GI_TYPE_TAG_INTERFACE:
         rb_raise(rb_eNotImpError,
-                 "TODO: allocates GIArgument(array)[c][%s] for output",
-                 g_type_tag_to_string(element_type_tag));
+                 "TODO: free GIArgument(%s) as container",
+                 g_type_tag_to_string(type_tag));
         break;
-      default:
-        g_base_info_unref(element_type_info);
-        g_assert_not_reached();
+    case GI_TYPE_TAG_GLIST:
+        g_list_free(argument->v_pointer);
         break;
-    }
-}
-static void
-rb_gi_out_argument_init_array_array_interface(GIArgument *argument,
-                                              G_GNUC_UNUSED GIArgInfo *arg_info,
-                                              GITypeInfo *array_type_info,
-                                              GITypeInfo *element_type_info)
-{
-    gboolean zero_terminated_p;
-    GIBaseInfo *interface_info;
-    GIInfoType interface_type;
-    GType gtype;
-    const char *interface_name;
-    zero_terminated_p = g_type_info_is_zero_terminated(array_type_info);
-    interface_info = g_type_info_get_interface(element_type_info);
-    interface_type = g_base_info_get_type(interface_info);
-    gtype = g_registered_type_info_get_g_type(interface_info);
-    switch (interface_type) {
-    case GI_INFO_TYPE_INVALID:
-    case GI_INFO_TYPE_FUNCTION:
-    case GI_INFO_TYPE_CALLBACK:
-        interface_name = g_info_type_to_string(interface_type);
-        g_base_info_unref(interface_info);
-        g_base_info_unref(element_type_info);
-        rb_raise(rb_eNotImpError,
-                 "TODO: GIArgument(array)[array][interface(%s)](%s) -> Ruby",
-                 interface_name,
-                 g_type_name(gtype));
+    case GI_TYPE_TAG_GSLIST:
+        g_slist_free(argument->v_pointer);
         break;
-    case GI_INFO_TYPE_STRUCT:
-    {
-        gsize raw_struct_size;
-        guint struct_size;
-        raw_struct_size = g_struct_info_get_size(interface_info);
-        struct_size = (guint)raw_struct_size;
-        argument->v_pointer = g_array_new(zero_terminated_p,
-                                          TRUE,
-                                          struct_size);
+    case GI_TYPE_TAG_GHASH:
+        g_hash_table_unref(argument->v_pointer);
         break;
-    }
-    case GI_INFO_TYPE_BOXED:
-    case GI_INFO_TYPE_ENUM:
-    case GI_INFO_TYPE_FLAGS:
-    case GI_INFO_TYPE_OBJECT:
-    case GI_INFO_TYPE_INTERFACE:
-    case GI_INFO_TYPE_CONSTANT:
-    case GI_INFO_TYPE_INVALID_0:
-    case GI_INFO_TYPE_UNION:
-    case GI_INFO_TYPE_VALUE:
-    case GI_INFO_TYPE_SIGNAL:
-    case GI_INFO_TYPE_VFUNC:
-    case GI_INFO_TYPE_PROPERTY:
-    case GI_INFO_TYPE_FIELD:
-    case GI_INFO_TYPE_ARG:
-    case GI_INFO_TYPE_TYPE:
-    case GI_INFO_TYPE_UNRESOLVED:
-        interface_name = g_info_type_to_string(interface_type);
-        g_base_info_unref(interface_info);
-        g_base_info_unref(element_type_info);
+    case GI_TYPE_TAG_ERROR:
+    case GI_TYPE_TAG_UNICHAR:
         rb_raise(rb_eNotImpError,
-                 "TODO: GIArgument(array)[array][interface(%s)](%s) -> Ruby",
-                 interface_name,
-                 g_type_name(gtype));
+                 "TODO: free GIArgument(%s) as container",
+                 g_type_tag_to_string(type_tag));
         break;
     default:
-        g_base_info_unref(interface_info);
-        g_base_info_unref(element_type_info);
         g_assert_not_reached();
         break;
     }
-    g_base_info_unref(interface_info);
 }
 static void
-rb_gi_out_argument_init_array_array(GIArgument *argument,
-                                    GIArgInfo *arg_info,
-                                    GITypeInfo *array_type_info,
-                                    GITypeInfo *element_type_info)
+rb_gi_return_argument_free_everything_array_c(GIArgument *argument,
+                                              GITypeInfo *type_info)
 {
+    GITypeInfo *element_type_info;
     GITypeTag element_type_tag;
+    element_type_info = g_type_info_get_param_type(type_info, 0);
     element_type_tag = g_type_info_get_tag(element_type_info);
+    g_base_info_unref(element_type_info);
     switch (element_type_tag) {
     case GI_TYPE_TAG_VOID:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(array)[c][%s] everything",
+                 g_type_tag_to_string(element_type_tag));
+        break;
     case GI_TYPE_TAG_BOOLEAN:
     case GI_TYPE_TAG_INT8:
     case GI_TYPE_TAG_UINT8:
@@ -1581,2753 +1468,250 @@ rb_gi_out_argument_init_array_array(GIArgument *argument,
     case GI_TYPE_TAG_UINT64:
     case GI_TYPE_TAG_FLOAT:
     case GI_TYPE_TAG_DOUBLE:
+        g_free(argument->v_pointer);
+        break;
     case GI_TYPE_TAG_GTYPE:
-    case GI_TYPE_TAG_UTF8:
-    case GI_TYPE_TAG_FILENAME:
-    case GI_TYPE_TAG_ARRAY:
-        g_base_info_unref(element_type_info);
         rb_raise(rb_eNotImpError,
-                 "TODO: allocates GIArgument(array)[array][%s] for output",
+                 "TODO: free GIArgument(array)[c][%s] everything",
                  g_type_tag_to_string(element_type_tag));
         break;
-    case GI_TYPE_TAG_INTERFACE:
-        rb_gi_out_argument_init_array_array_interface(argument,
-                                                      arg_info,
-                                                      array_type_info,
-                                                      element_type_info);
+    case GI_TYPE_TAG_UTF8:
+        g_strfreev(argument->v_pointer);
+        break;
+    case GI_TYPE_TAG_FILENAME:
+        g_strfreev(argument->v_pointer);
         break;
+    case GI_TYPE_TAG_ARRAY:
+    case GI_TYPE_TAG_INTERFACE:
     case GI_TYPE_TAG_GLIST:
     case GI_TYPE_TAG_GSLIST:
     case GI_TYPE_TAG_GHASH:
     case GI_TYPE_TAG_ERROR:
     case GI_TYPE_TAG_UNICHAR:
-        g_base_info_unref(element_type_info);
         rb_raise(rb_eNotImpError,
-                 "TODO: allocates GIArgument(array)[array][%s] for output",
+                 "TODO: free GIArgument(array)[c][%s] everything",
                  g_type_tag_to_string(element_type_tag));
         break;
     default:
-        g_base_info_unref(element_type_info);
         g_assert_not_reached();
         break;
     }
 }
 static void
-rb_gi_out_argument_init_array(GIArgument *argument, GIArgInfo *arg_info,
-                              GITypeInfo *array_type_info)
+rb_gi_return_argument_free_everything_array(GIArgument *argument,
+                                            GITypeInfo *type_info)
 {
-    GIArrayType array_type;
-    GITypeInfo *element_type_info;
-    GITypeTag element_type_tag;
-    array_type = g_type_info_get_array_type(array_type_info);
-    element_type_info = g_type_info_get_param_type(array_type_info, 0);
-    element_type_tag = g_type_info_get_tag(element_type_info);
-    switch (array_type) {
+    switch (g_type_info_get_array_type(type_info)) {
     case GI_ARRAY_TYPE_C:
-        rb_gi_out_argument_init_array_c(argument,
-                                        arg_info,
-                                        array_type_info,
-                                        element_type_info);
+        rb_gi_return_argument_free_everything_array_c(argument, type_info);
         break;
     case GI_ARRAY_TYPE_ARRAY:
-        rb_gi_out_argument_init_array_array(argument,
-                                            arg_info,
-                                            array_type_info,
-                                            element_type_info);
+        g_array_free(argument->v_pointer, TRUE);
         break;
     case GI_ARRAY_TYPE_PTR_ARRAY:
-        g_base_info_unref(element_type_info);
-        rb_raise(rb_eNotImpError,
-                 "TODO: allocates GIArgument(array)[ptr-array][%s] for output",
-                 g_type_tag_to_string(element_type_tag));
+        g_ptr_array_free(argument->v_pointer, TRUE);
         break;
     case GI_ARRAY_TYPE_BYTE_ARRAY:
-        g_base_info_unref(element_type_info);
-        rb_raise(rb_eNotImpError,
-                 "TODO: allocates GIArgument(array)[byte-array][%s] for output",
-                 g_type_tag_to_string(element_type_tag));
+        g_ptr_array_free(argument->v_pointer, TRUE);
         break;
     default:
-        g_base_info_unref(element_type_info);
         g_assert_not_reached();
         break;
     }
+}
-    g_base_info_unref(element_type_info);
+static void
+rb_gi_return_argument_free_everything_interface_struct(GIArgument *argument,
+                                                       GType       gtype)
+{
+    if (!argument->v_pointer) {
+        return;
+    }
+    if (!gtype) {
+        xfree(argument->v_pointer);
+    }
+    if (G_TYPE_IS_BOXED(gtype)) {
+        g_boxed_free(gtype, argument->v_pointer);
+    } else {
+        rbgobj_instance_unref(argument->v_pointer);
+    }
 }
 static void
-rb_gi_out_argument_init_interface(GIArgument *argument,
-                                  G_GNUC_UNUSED GIArgInfo *arg_info,
-                                  GITypeInfo *type_info)
+rb_gi_return_argument_free_everything_interface(GIArgument *argument,
+                                                GITypeInfo *type_info)
 {
     GIBaseInfo *interface_info;
     GIInfoType interface_type;
-    /* TODO: Can we use the following code? */
-    /*
-    if (!g_arg_info_is_caller_allocates(arg_info)) {
-        argument->v_pointer = ALLOC(gpointer);
-        return;
-    }
-    */
+    GType gtype;
     interface_info = g_type_info_get_interface(type_info);
     interface_type = g_base_info_get_type(interface_info);
+    gtype = g_registered_type_info_get_g_type(interface_info);
+    g_base_info_unref(interface_info);
     switch (interface_type) {
     case GI_INFO_TYPE_INVALID:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[invalid] everything");
+        break;
     case GI_INFO_TYPE_FUNCTION:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[function] everything");
+        break;
     case GI_INFO_TYPE_CALLBACK:
         rb_raise(rb_eNotImpError,
-                 "TODO: allocates GIArgument(interface)[%s] for output",
-                 g_info_type_to_string(interface_type));
+                 "TODO: free GIArgument(interface)[callback] everything");
         break;
     case GI_INFO_TYPE_STRUCT:
-    {
-        gsize struct_size;
-        /* Should we care gtype?
-           Related: rb_gi_out_argument_fin_interface() */
-        struct_size = g_struct_info_get_size(interface_info);
-        argument->v_pointer = xmalloc(struct_size);
-        memset(argument->v_pointer, 0, struct_size);
-    }
-    break;
+        rb_gi_return_argument_free_everything_interface_struct(argument, gtype);
+        break;
     case GI_INFO_TYPE_BOXED:
-      rb_raise(rb_eNotImpError,
-               "TODO: allocates GIArgument(interface)[%s] for output",
-               g_info_type_to_string(interface_type));
-      break;
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[boxed] everything");
+        break;
     case GI_INFO_TYPE_ENUM:
-      {
-          gint *pointer = ALLOC(gint);
-          *pointer = 0;
-          argument->v_pointer = pointer;
-      }
-      break;
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[enum] everything");
+        break;
     case GI_INFO_TYPE_FLAGS:
-      {
-          guint *pointer = ALLOC(guint);
-          *pointer = 0;
-          argument->v_pointer = pointer;
-      }
-      break;
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[flags] everything");
+        break;
     case GI_INFO_TYPE_OBJECT:
-    case GI_INFO_TYPE_INTERFACE:
-      {
-          gpointer *pointer = ALLOC(gpointer);
-          *pointer = NULL;
-          argument->v_pointer = pointer;
-      }
-      break;
-    case GI_INFO_TYPE_CONSTANT:
-    case GI_INFO_TYPE_INVALID_0:
-    case GI_INFO_TYPE_UNION:
-    case GI_INFO_TYPE_VALUE:
-    case GI_INFO_TYPE_SIGNAL:
-    case GI_INFO_TYPE_VFUNC:
-    case GI_INFO_TYPE_PROPERTY:
-    case GI_INFO_TYPE_FIELD:
-    case GI_INFO_TYPE_ARG:
-    case GI_INFO_TYPE_TYPE:
-    case GI_INFO_TYPE_UNRESOLVED:
-        rb_raise(rb_eNotImpError,
-                 "TODO: allocates GIArgument(interface)[%s] for output",
-                 g_info_type_to_string(interface_type));
-        break;
-    default:
-        g_assert_not_reached();
-        break;
-    }
-    g_base_info_unref(interface_info);
-}
-void
-rb_gi_out_argument_init(GIArgument *argument, GIArgInfo *arg_info)
-{
-    GITypeInfo type_info;
-    GITypeTag type_tag;
-    memset(argument, 0, sizeof(GIArgument));
-    g_arg_info_load_type(arg_info, &type_info);
-    type_tag = g_type_info_get_tag(&type_info);
-    switch (type_tag) {
-      case GI_TYPE_TAG_VOID:
-        if (g_type_info_is_pointer(&type_info)) {
-            gpointer *pointer = ALLOC(gpointer);
-            *pointer = NULL;
-            argument->v_pointer = pointer;
-        }
-        break;
-      case GI_TYPE_TAG_BOOLEAN:
-        {
-            gboolean *pointer = ALLOC(gboolean);
-            *pointer = FALSE;
-            argument->v_pointer = pointer;
-        }
-        break;
-      case GI_TYPE_TAG_INT8:
-        {
-            gint8 *pointer = ALLOC(gint8);
-            *pointer = 0;
-            argument->v_pointer = pointer;
-        }
-        break;
-      case GI_TYPE_TAG_UINT8:
-        {
-            guint8 *pointer = ALLOC(guint8);
-            *pointer = 0;
-            argument->v_pointer = pointer;
-        }
-        break;
-      case GI_TYPE_TAG_INT16:
-        {
-            gint16 *pointer = ALLOC(gint16);
-            *pointer = 0;
-            argument->v_pointer = pointer;
-        }
-        break;
-      case GI_TYPE_TAG_UINT16:
-        {
-            guint16 *pointer = ALLOC(guint16);
-            *pointer = 0;
-            argument->v_pointer = pointer;
-        }
-        break;
-      case GI_TYPE_TAG_INT32:
-        {
-            gint32 *pointer = ALLOC(gint32);
-            *pointer = 0;
-            argument->v_pointer = pointer;
-        }
-        break;
-      case GI_TYPE_TAG_UINT32:
-        {
-            guint32 *pointer = ALLOC(guint32);
-            *pointer = 0;
-            argument->v_pointer = pointer;
-        }
-        break;
-      case GI_TYPE_TAG_INT64:
-        {
-            gint64 *pointer = ALLOC(gint64);
-            *pointer = 0;
-            argument->v_pointer = pointer;
-        }
-        break;
-      case GI_TYPE_TAG_UINT64:
-        {
-            guint64 *pointer = ALLOC(guint64);
-            *pointer = 0;
-            argument->v_pointer = pointer;
-        }
-        break;
-      case GI_TYPE_TAG_FLOAT:
-        {
-            gfloat *pointer = ALLOC(gfloat);
-            *pointer = 0.0;
-            argument->v_pointer = pointer;
-        }
-        break;
-      case GI_TYPE_TAG_DOUBLE:
-        {
-            gdouble *pointer = ALLOC(gdouble);
-            *pointer = 0.0;
-            argument->v_pointer = pointer;
-        }
-        break;
-      case GI_TYPE_TAG_GTYPE:
-        {
-            GType *pointer = ALLOC(GType);
-            *pointer = G_TYPE_INVALID;
-            argument->v_pointer = pointer;
-        }
-        break;
-      case GI_TYPE_TAG_UTF8:
-      case GI_TYPE_TAG_FILENAME:
-        {
-            gchar **pointer = ALLOC(gchar *);
-            *pointer = NULL;
-            argument->v_pointer = pointer;
-        }
-        break;
-      case GI_TYPE_TAG_ARRAY:
-        rb_gi_out_argument_init_array(argument, arg_info, &type_info);
-        break;
-      case GI_TYPE_TAG_INTERFACE:
-        rb_gi_out_argument_init_interface(argument, arg_info, &type_info);
-        break;
-      case GI_TYPE_TAG_GLIST:
-      case GI_TYPE_TAG_GSLIST:
-      case GI_TYPE_TAG_GHASH:
-        {
-            gpointer *pointer = ALLOC(gpointer);
-            *pointer = NULL;
-            argument->v_pointer = pointer;
-        }
-        break;
-      case GI_TYPE_TAG_ERROR:
-        {
-            GError **pointer = ALLOC(GError *);
-            *pointer = NULL;
-            argument->v_pointer = pointer;
-        }
-        break;
-      case GI_TYPE_TAG_UNICHAR:
-        {
-            gunichar *pointer = ALLOC(gunichar);
-            *pointer = 0;
-            argument->v_pointer = pointer;
-        }
-        break;
-      default:
-        g_assert_not_reached();
-        break;
-    }
-}
-VALUE
-rb_gi_out_argument_to_ruby(GIArgument *argument,
-                           GIArgInfo *arg_info,
-                           GArray *in_args,
-                           GArray *out_args,
-                           GPtrArray *args_metadata)
-{
-    GIArgument normalized_argument;
-    GITypeInfo type_info;
-    GITypeTag type_tag;
-    gboolean duplicate = FALSE;
-    memset(&normalized_argument, 0, sizeof(GIArgument));
-    g_arg_info_load_type(arg_info, &type_info);
-    type_tag = g_type_info_get_tag(&type_info);
-    switch (type_tag) {
-      case GI_TYPE_TAG_VOID:
-        if (g_type_info_is_pointer(&type_info)) {
-            normalized_argument.v_pointer = *((gpointer *)(argument->v_pointer));
-        }
-        break;
-      case GI_TYPE_TAG_BOOLEAN:
-        normalized_argument.v_boolean = *((gboolean *)(argument->v_pointer));
-        break;
-      case GI_TYPE_TAG_INT8:
-        normalized_argument.v_int8 = *((gint8 *)(argument->v_pointer));
-        break;
-      case GI_TYPE_TAG_UINT8:
-        normalized_argument.v_uint8 = *((guint8 *)(argument->v_pointer));
-        break;
-      case GI_TYPE_TAG_INT16:
-        normalized_argument.v_int16 = *((gint16 *)(argument->v_pointer));
-        break;
-      case GI_TYPE_TAG_UINT16:
-        normalized_argument.v_uint16 = *((guint16 *)(argument->v_pointer));
-        break;
-      case GI_TYPE_TAG_INT32:
-        normalized_argument.v_int32 = *((gint32 *)(argument->v_pointer));
-        break;
-      case GI_TYPE_TAG_UINT32:
-        normalized_argument.v_uint32 = *((guint32 *)(argument->v_pointer));
-        break;
-      case GI_TYPE_TAG_INT64:
-        normalized_argument.v_int64 = *((gint64 *)(argument->v_pointer));
-        break;
-      case GI_TYPE_TAG_UINT64:
-        normalized_argument.v_uint64 = *((guint64 *)(argument->v_pointer));
-        break;
-      case GI_TYPE_TAG_FLOAT:
-        normalized_argument.v_float = *((gfloat *)(argument->v_pointer));
-        break;
-      case GI_TYPE_TAG_DOUBLE:
-        normalized_argument.v_double = *((gdouble *)(argument->v_pointer));
-        break;
-      case GI_TYPE_TAG_GTYPE:
-        normalized_argument.v_size = *((GType *)(argument->v_pointer));
-        break;
-      case GI_TYPE_TAG_UTF8:
-      case GI_TYPE_TAG_FILENAME:
-        normalized_argument.v_string = *((gchar **)(argument->v_pointer));
-        break;
-      case GI_TYPE_TAG_ARRAY:
-      case GI_TYPE_TAG_INTERFACE:
-      case GI_TYPE_TAG_GLIST:
-      case GI_TYPE_TAG_GSLIST:
-      case GI_TYPE_TAG_GHASH:
-        if (g_arg_info_is_caller_allocates(arg_info)) {
-            duplicate = TRUE;
-            normalized_argument.v_pointer = argument->v_pointer;
-        } else {
-            normalized_argument.v_pointer = *((gpointer *)(argument->v_pointer));
-        }
-        break;
-      case GI_TYPE_TAG_ERROR:
-        normalized_argument.v_pointer = *((GError **)(argument->v_pointer));
-        break;
-      case GI_TYPE_TAG_UNICHAR:
-        normalized_argument.v_uint32 = *((guint32 *)(argument->v_pointer));
-        break;
-      default:
-        g_assert_not_reached();
-        break;
-    }
-    return rb_gi_argument_to_ruby(&normalized_argument,
-                                  duplicate,
-                                  &type_info,
-                                  in_args,
-                                  out_args,
-                                  args_metadata);
-}
-static void
-rb_gi_out_argument_fin_array_c(GIArgument *argument,
-                               G_GNUC_UNUSED GIArgInfo *arg_info,
-                               G_GNUC_UNUSED GITypeInfo *array_type_info,
-                               GITypeInfo *element_type_info,
-                               GITransfer transfer)
-{
-    GITypeTag element_type_tag;
-    element_type_tag = g_type_info_get_tag(element_type_info);
-    switch (element_type_tag) {
-      case GI_TYPE_TAG_VOID:
-      case GI_TYPE_TAG_BOOLEAN:
-      case GI_TYPE_TAG_INT8:
-        g_base_info_unref(element_type_info);
-        rb_raise(rb_eNotImpError,
-                 "TODO: free out GIArgument(array)[c][%s]",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-      case GI_TYPE_TAG_UINT8:
-        if (transfer == GI_TRANSFER_EVERYTHING) {
-            g_free(*((guint8 **)(argument->v_pointer)));
-        }
-        xfree(argument->v_pointer);
-        break;
-      case GI_TYPE_TAG_INT16:
-      case GI_TYPE_TAG_UINT16:
-      case GI_TYPE_TAG_INT32:
-      case GI_TYPE_TAG_UINT32:
-      case GI_TYPE_TAG_INT64:
-      case GI_TYPE_TAG_UINT64:
-      case GI_TYPE_TAG_FLOAT:
-      case GI_TYPE_TAG_DOUBLE:
-      case GI_TYPE_TAG_GTYPE:
-        g_base_info_unref(element_type_info);
-        rb_raise(rb_eNotImpError,
-                 "TODO: free out GIArgument(array)[c][%s]",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-      case GI_TYPE_TAG_UTF8:
-        if (transfer != GI_TRANSFER_NOTHING) {
-            g_free(*((gchar **)argument->v_pointer));
-        }
-        xfree(argument->v_pointer);
-        break;
-      case GI_TYPE_TAG_FILENAME:
-      case GI_TYPE_TAG_ARRAY:
-        g_base_info_unref(element_type_info);
-        rb_raise(rb_eNotImpError,
-                 "TODO: free out GIArgument(array)[c][%s]",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-      case GI_TYPE_TAG_INTERFACE:
-        if (transfer == GI_TRANSFER_EVERYTHING) {
-            g_base_info_unref(element_type_info);
-            rb_raise(rb_eNotImpError,
-                     "TODO: free out transfer GIArgument(array)[c][%s][%s]",
-                     g_type_tag_to_string(element_type_tag),
-                     rb_gi_transfer_to_string(transfer));
-        }
-        if (transfer != GI_TRANSFER_NOTHING) {
-            g_free(*((gpointer *)argument->v_pointer));
-        }
-        xfree(argument->v_pointer);
-        break;
-      case GI_TYPE_TAG_GLIST:
-      case GI_TYPE_TAG_GSLIST:
-      case GI_TYPE_TAG_GHASH:
-      case GI_TYPE_TAG_ERROR:
-      case GI_TYPE_TAG_UNICHAR:
-        g_base_info_unref(element_type_info);
-        rb_raise(rb_eNotImpError,
-                 "TODO: free out GIArgument(array)[c][%s]",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-      default:
-        g_base_info_unref(element_type_info);
-        g_assert_not_reached();
-        break;
-    }
-}
-static void
-rb_gi_out_argument_fin_array(GIArgument *argument,
-                             GIArgInfo *arg_info,
-                             GITypeInfo *array_type_info,
-                             GITransfer transfer)
-{
-    GIArrayType array_type;
-    GITypeInfo *element_type_info;
-    GITypeTag element_type_tag;
-    array_type = g_type_info_get_array_type(array_type_info);
-    element_type_info = g_type_info_get_param_type(array_type_info, 0);
-    element_type_tag = g_type_info_get_tag(element_type_info);
-    switch (array_type) {
-    case GI_ARRAY_TYPE_C:
-        rb_gi_out_argument_fin_array_c(argument,
-                                       arg_info,
-                                       array_type_info,
-                                       element_type_info,
-                                       transfer);
-        break;
-    case GI_ARRAY_TYPE_ARRAY:
-        if (transfer != GI_TRANSFER_NOTHING) {
-            g_base_info_unref(element_type_info);
-            rb_raise(rb_eNotImpError,
-                     "TODO: free out transfer GIArgument(array)[ptr-array][%s][%s]",
-                     g_type_tag_to_string(element_type_tag),
-                     rb_gi_transfer_to_string(transfer));
-        }
-        g_array_free(argument->v_pointer, TRUE);
-        break;
-    case GI_ARRAY_TYPE_PTR_ARRAY:
-        g_base_info_unref(element_type_info);
-        rb_raise(rb_eNotImpError,
-                 "TODO: free out GIArgument(array)[ptr-array][%s]",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-    case GI_ARRAY_TYPE_BYTE_ARRAY:
-        g_base_info_unref(element_type_info);
-        rb_raise(rb_eNotImpError,
-                 "TODO: free out GIArgument(array)[byte-array][%s]",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-    default:
-        g_base_info_unref(element_type_info);
-        g_assert_not_reached();
-        break;
-    }
-    g_base_info_unref(element_type_info);
-}
-static void
-rb_gi_out_argument_fin_interface(GIArgument *argument,
-                                 G_GNUC_UNUSED GIArgInfo *arg_info,
-                                 GITypeInfo *interface_type_info,
-                                 GITransfer transfer)
-{
-    GIBaseInfo *interface_info;
-    GIInfoType interface_type;
-    interface_info = g_type_info_get_interface(interface_type_info);
-    interface_type = g_base_info_get_type(interface_info);
-    g_base_info_unref(interface_info);
-    switch (interface_type) {
-      case GI_INFO_TYPE_INVALID:
-      case GI_INFO_TYPE_FUNCTION:
-      case GI_INFO_TYPE_CALLBACK:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free out transfer GIArgument(interface)[%s][%s]",
-                 g_info_type_to_string(interface_type),
-                 rb_gi_transfer_to_string(transfer));
-        break;
-      case GI_INFO_TYPE_STRUCT:
-        /* Should we care gtype?
-           Related: rb_gi_out_argument_init_interface() */
-        xfree(argument->v_pointer);
-        break;
-      case GI_INFO_TYPE_BOXED:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free out transfer GIArgument(interface)[%s][%s]",
-                 g_info_type_to_string(interface_type),
-                 rb_gi_transfer_to_string(transfer));
-        break;
-      case GI_INFO_TYPE_ENUM:
-      case GI_INFO_TYPE_FLAGS:
-        break;
-      case GI_INFO_TYPE_OBJECT:
-        switch (transfer) {
-          case GI_TRANSFER_NOTHING:
-            break;
-          case GI_TRANSFER_CONTAINER:
-          case GI_TRANSFER_EVERYTHING:
-            {
-                GObject *object = *((GObject **)argument->v_pointer);
-                if (object) {
-                    g_object_unref(object);
-                }
-            }
-            break;
-          default:
-            rb_raise(rb_eNotImpError,
-                     "TODO: free out transfer GIArgument(interface)[%s][%s]",
-                     g_info_type_to_string(interface_type),
-                     rb_gi_transfer_to_string(transfer));
-            break;
-        }
-        xfree(argument->v_pointer);
-        break;
-      case GI_INFO_TYPE_INTERFACE:
-        if (transfer != GI_TRANSFER_NOTHING) {
-            rb_raise(rb_eNotImpError,
-                     "TODO: free out transfer GIArgument(interface)[%s][%s]",
-                     g_info_type_to_string(interface_type),
-                     rb_gi_transfer_to_string(transfer));
-        }
-        xfree(argument->v_pointer);
-        break;
-      case GI_INFO_TYPE_CONSTANT:
-      case GI_INFO_TYPE_INVALID_0:
-      case GI_INFO_TYPE_UNION:
-      case GI_INFO_TYPE_VALUE:
-      case GI_INFO_TYPE_SIGNAL:
-      case GI_INFO_TYPE_VFUNC:
-      case GI_INFO_TYPE_PROPERTY:
-      case GI_INFO_TYPE_FIELD:
-      case GI_INFO_TYPE_ARG:
-      case GI_INFO_TYPE_TYPE:
-      case GI_INFO_TYPE_UNRESOLVED:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free out transfer GIArgument(interface)[%s][%s]",
-                 g_info_type_to_string(interface_type),
-                 rb_gi_transfer_to_string(transfer));
-        break;
-      default:
-        g_assert_not_reached();
-        break;
-    }
-}
-void
-rb_gi_out_argument_fin(GIArgument *argument, GIArgInfo *arg_info)
-{
-    GITypeInfo type_info;
-    GITypeTag type_tag;
-    GITransfer transfer;
-    if (g_arg_info_get_direction(arg_info) != GI_DIRECTION_OUT) {
-        return;
-    }
-    g_arg_info_load_type(arg_info, &type_info);
-    type_tag = g_type_info_get_tag(&type_info);
-    transfer = g_arg_info_get_ownership_transfer(arg_info);
-    switch (type_tag) {
-    case GI_TYPE_TAG_VOID:
-    case GI_TYPE_TAG_BOOLEAN:
-    case GI_TYPE_TAG_INT8:
-    case GI_TYPE_TAG_UINT8:
-    case GI_TYPE_TAG_INT16:
-    case GI_TYPE_TAG_UINT16:
-    case GI_TYPE_TAG_INT32:
-    case GI_TYPE_TAG_UINT32:
-    case GI_TYPE_TAG_INT64:
-    case GI_TYPE_TAG_UINT64:
-    case GI_TYPE_TAG_FLOAT:
-    case GI_TYPE_TAG_DOUBLE:
-    case GI_TYPE_TAG_GTYPE:
-        xfree(argument->v_pointer);
-        break;
-    case GI_TYPE_TAG_UTF8:
-        if (transfer != GI_TRANSFER_NOTHING) {
-            g_free(*((gchar **)argument->v_pointer));
-        }
-        xfree(argument->v_pointer);
-        break;
-    case GI_TYPE_TAG_FILENAME:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free out GIArgument(%s)",
-                 g_type_tag_to_string(type_tag));
-        break;
-    case GI_TYPE_TAG_ARRAY:
-        rb_gi_out_argument_fin_array(argument, arg_info, &type_info, transfer);
-        break;
-    case GI_TYPE_TAG_INTERFACE:
-        rb_gi_out_argument_fin_interface(argument,
-                                         arg_info,
-                                         &type_info,
-                                         transfer);
-        break;
-    case GI_TYPE_TAG_GLIST:
-        if (transfer == GI_TRANSFER_EVERYTHING) {
-            rb_raise(rb_eNotImpError,
-                     "TODO: free out transfer GIArgument(%s)[%s]",
-                     g_type_tag_to_string(type_tag),
-                     rb_gi_transfer_to_string(transfer));
-        }
-        if (transfer != GI_TRANSFER_NOTHING) {
-            g_list_free(*((GList **)argument->v_pointer));
-        }
-        xfree(argument->v_pointer);
-        break;
-    case GI_TYPE_TAG_GSLIST:
-    case GI_TYPE_TAG_GHASH:
-    case GI_TYPE_TAG_ERROR:
-        if (transfer != GI_TRANSFER_NOTHING) {
-            rb_raise(rb_eNotImpError,
-                     "TODO: free out transfer GIArgument(%s)[%s]",
-                     g_type_tag_to_string(type_tag),
-                     rb_gi_transfer_to_string(transfer));
-        }
-        xfree(argument->v_pointer);
-        break;
-    case GI_TYPE_TAG_UNICHAR:
-        xfree(argument->v_pointer);
-        break;
-    default:
-        g_assert_not_reached();
-        break;
-    }
-}
-static void
-rb_gi_return_argument_free_container(GIArgument *argument,
-                                     GITypeInfo *type_info)
-{
-    GITypeTag type_tag;
-    type_tag = g_type_info_get_tag(type_info);
-    switch (type_tag) {
-    case GI_TYPE_TAG_VOID:
-    case GI_TYPE_TAG_BOOLEAN:
-    case GI_TYPE_TAG_INT8:
-    case GI_TYPE_TAG_UINT8:
-    case GI_TYPE_TAG_INT16:
-    case GI_TYPE_TAG_UINT16:
-    case GI_TYPE_TAG_INT32:
-    case GI_TYPE_TAG_UINT32:
-    case GI_TYPE_TAG_INT64:
-    case GI_TYPE_TAG_UINT64:
-    case GI_TYPE_TAG_FLOAT:
-    case GI_TYPE_TAG_DOUBLE:
-    case GI_TYPE_TAG_GTYPE:
-    case GI_TYPE_TAG_UTF8:
-    case GI_TYPE_TAG_FILENAME:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(%s) as container",
-                 g_type_tag_to_string(type_tag));
-        break;
-    case GI_TYPE_TAG_ARRAY:
-        g_free(argument->v_pointer);
-        break;
-    case GI_TYPE_TAG_INTERFACE:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(%s) as container",
-                 g_type_tag_to_string(type_tag));
-        break;
-    case GI_TYPE_TAG_GLIST:
-        g_list_free(argument->v_pointer);
-        break;
-    case GI_TYPE_TAG_GSLIST:
-        g_slist_free(argument->v_pointer);
-        break;
-    case GI_TYPE_TAG_GHASH:
-        g_hash_table_unref(argument->v_pointer);
-        break;
-    case GI_TYPE_TAG_ERROR:
-    case GI_TYPE_TAG_UNICHAR:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(%s) as container",
-                 g_type_tag_to_string(type_tag));
-        break;
-    default:
-        g_assert_not_reached();
-        break;
-    }
-}
-static void
-rb_gi_return_argument_free_everything_array_c(GIArgument *argument,
-                                              GITypeInfo *type_info)
-{
-    GITypeInfo *element_type_info;
-    GITypeTag element_type_tag;
-    element_type_info = g_type_info_get_param_type(type_info, 0);
-    element_type_tag = g_type_info_get_tag(element_type_info);
-    g_base_info_unref(element_type_info);
-    switch (element_type_tag) {
-    case GI_TYPE_TAG_VOID:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(array)[c][%s] everything",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-    case GI_TYPE_TAG_BOOLEAN:
-    case GI_TYPE_TAG_INT8:
-    case GI_TYPE_TAG_UINT8:
-    case GI_TYPE_TAG_INT16:
-    case GI_TYPE_TAG_UINT16:
-    case GI_TYPE_TAG_INT32:
-    case GI_TYPE_TAG_UINT32:
-    case GI_TYPE_TAG_INT64:
-    case GI_TYPE_TAG_UINT64:
-    case GI_TYPE_TAG_FLOAT:
-    case GI_TYPE_TAG_DOUBLE:
-        g_free(argument->v_pointer);
-        break;
-    case GI_TYPE_TAG_GTYPE:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(array)[c][%s] everything",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-    case GI_TYPE_TAG_UTF8:
-        g_strfreev(argument->v_pointer);
-        break;
-    case GI_TYPE_TAG_FILENAME:
-        g_strfreev(argument->v_pointer);
-        break;
-    case GI_TYPE_TAG_ARRAY:
-    case GI_TYPE_TAG_INTERFACE:
-    case GI_TYPE_TAG_GLIST:
-    case GI_TYPE_TAG_GSLIST:
-    case GI_TYPE_TAG_GHASH:
-    case GI_TYPE_TAG_ERROR:
-    case GI_TYPE_TAG_UNICHAR:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(array)[c][%s] everything",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-    default:
-        g_assert_not_reached();
-        break;
-    }
-}
-static void
-rb_gi_return_argument_free_everything_array(GIArgument *argument,
-                                            GITypeInfo *type_info)
-{
-    switch (g_type_info_get_array_type(type_info)) {
-    case GI_ARRAY_TYPE_C:
-        rb_gi_return_argument_free_everything_array_c(argument, type_info);
-        break;
-    case GI_ARRAY_TYPE_ARRAY:
-        g_array_free(argument->v_pointer, TRUE);
-        break;
-    case GI_ARRAY_TYPE_PTR_ARRAY:
-        g_ptr_array_free(argument->v_pointer, TRUE);
-        break;
-    case GI_ARRAY_TYPE_BYTE_ARRAY:
-        g_ptr_array_free(argument->v_pointer, TRUE);
-        break;
-    default:
-        g_assert_not_reached();
-        break;
-    }
-}
-static void
-rb_gi_return_argument_free_everything_interface_struct(GIArgument *argument,
-                                                       GType       gtype)
-{
-    if (!argument->v_pointer) {
-        return;
-    }
-    if (!gtype) {
-        xfree(argument->v_pointer);
-    }
-    if (G_TYPE_IS_BOXED(gtype)) {
-        g_boxed_free(gtype, argument->v_pointer);
-    } else {
-        rbgobj_instance_unref(argument->v_pointer);
-    }
-}
-static void
-rb_gi_return_argument_free_everything_interface(GIArgument *argument,
-                                                GITypeInfo *type_info)
-{
-    GIBaseInfo *interface_info;
-    GIInfoType interface_type;
-    GType gtype;
-    interface_info = g_type_info_get_interface(type_info);
-    interface_type = g_base_info_get_type(interface_info);
-    gtype = g_registered_type_info_get_g_type(interface_info);
-    g_base_info_unref(interface_info);
-    switch (interface_type) {
-    case GI_INFO_TYPE_INVALID:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(interface)[invalid] everything");
-        break;
-    case GI_INFO_TYPE_FUNCTION:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(interface)[function] everything");
-        break;
-    case GI_INFO_TYPE_CALLBACK:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(interface)[callback] everything");
-        break;
-    case GI_INFO_TYPE_STRUCT:
-        rb_gi_return_argument_free_everything_interface_struct(argument, gtype);
-        break;
-    case GI_INFO_TYPE_BOXED:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(interface)[boxed] everything");
-        break;
-    case GI_INFO_TYPE_ENUM:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(interface)[enum] everything");
-        break;
-    case GI_INFO_TYPE_FLAGS:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(interface)[flags] everything");
-        break;
-    case GI_INFO_TYPE_OBJECT:
-        if (argument->v_pointer) {
-            GObject *object = argument->v_pointer;
-            if (g_object_is_floating(object)) {
-                g_object_ref_sink(object);
-            }
-            g_object_unref(object);
-        }
-        break;
-    case GI_INFO_TYPE_INTERFACE:
-        if (argument->v_pointer) {
-            g_object_unref(argument->v_pointer);
-        }
-        break;
-    case GI_INFO_TYPE_CONSTANT:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(interface)[constant] everything");
-        break;
-    case GI_INFO_TYPE_INVALID_0:
-        g_assert_not_reached();
-        break;
-    case GI_INFO_TYPE_UNION:
-      if (gtype == G_TYPE_NONE) {
-          rb_raise(rb_eNotImpError,
-                   "TODO: free GIArgument(interface)[union] everything");
-      } else {
-          g_boxed_free(gtype, argument->v_pointer);
-      }
-      break;
-    case GI_INFO_TYPE_VALUE:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(interface)[value] everything");
-        break;
-    case GI_INFO_TYPE_SIGNAL:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(interface)[signal] everything");
-        break;
-    case GI_INFO_TYPE_VFUNC:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(interface)[vfunc] everything");
-        break;
-    case GI_INFO_TYPE_PROPERTY:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(interface)[property] everything");
-        break;
-    case GI_INFO_TYPE_FIELD:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(interface)[field] everything");
-        break;
-    case GI_INFO_TYPE_ARG:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(interface)[arg] everything");
-        break;
-    case GI_INFO_TYPE_TYPE:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(interface)[type] everything");
-        break;
-    case GI_INFO_TYPE_UNRESOLVED:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(interface)[unresolved] everything");
-        break;
-    default:
-        g_assert_not_reached();
-        break;
-    }
-}
-static void
-rb_gi_boxed_free_callback(gpointer boxed, gpointer user_data)
-{
-    GType *gtype = user_data;
-    g_boxed_free(*gtype, boxed);
-}
-static void
-rb_gi_return_argument_free_everything_glist_interface(GIArgument *argument,
-                                                      G_GNUC_UNUSED GITypeInfo *type_info,
-                                                      GITypeInfo *element_type_info)
-{
-    GIBaseInfo *interface_info;
-    GIInfoType interface_type;
-    const gchar *interface_name;
-    GType gtype;
-    interface_info = g_type_info_get_interface(element_type_info);
-    interface_type = g_base_info_get_type(interface_info);
-    interface_name = g_info_type_to_string(interface_type);
-    gtype = g_registered_type_info_get_g_type(interface_info);
-    g_base_info_unref(interface_info);
-    g_base_info_unref(element_type_info);
-    switch (interface_type) {
-    case GI_INFO_TYPE_INVALID:
-    case GI_INFO_TYPE_FUNCTION:
-    case GI_INFO_TYPE_CALLBACK:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(GList)[interface(%s)](%s) everything",
-                 interface_name,
-                 g_type_name(gtype));
-        break;
-    case GI_INFO_TYPE_STRUCT:
-        if (gtype == G_TYPE_NONE) {
-            rb_raise(rb_eNotImpError,
-                     "TODO: free GIArgument(GList)[interface(%s)](%s) everything",
-                     interface_name,
-                     g_type_name(gtype));
-        } else {
-            g_list_foreach(argument->v_pointer,
-                           rb_gi_boxed_free_callback,
-                           &gtype);
-            g_list_free(argument->v_pointer);
-        }
-        break;
-    case GI_INFO_TYPE_BOXED:
-        g_list_foreach(argument->v_pointer, rb_gi_boxed_free_callback, &gtype);
-        g_list_free(argument->v_pointer);
-        break;
-    case GI_INFO_TYPE_ENUM:
-    case GI_INFO_TYPE_FLAGS:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(GList)[interface(%s)](%s) everything",
-                 interface_name,
-                 g_type_name(gtype));
-        break;
-    case GI_INFO_TYPE_OBJECT:
-    case GI_INFO_TYPE_INTERFACE:
-        g_list_foreach(argument->v_pointer, (GFunc)g_object_unref, NULL);
-        g_list_free(argument->v_pointer);
-        break;
-    case GI_INFO_TYPE_CONSTANT:
-    case GI_INFO_TYPE_INVALID_0:
-    case GI_INFO_TYPE_UNION:
-    case GI_INFO_TYPE_VALUE:
-    case GI_INFO_TYPE_SIGNAL:
-    case GI_INFO_TYPE_VFUNC:
-    case GI_INFO_TYPE_PROPERTY:
-    case GI_INFO_TYPE_FIELD:
-    case GI_INFO_TYPE_ARG:
-    case GI_INFO_TYPE_TYPE:
-    case GI_INFO_TYPE_UNRESOLVED:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(GList)[interface(%s)](%s) everything",
-                 interface_name,
-                 g_type_name(gtype));
-        break;
-    default:
-        g_assert_not_reached();
-        break;
-    }
-}
-static void
-rb_gi_return_argument_free_everything_glist(GIArgument *argument,
-                                            GITypeInfo *type_info)
-{
-    GITypeInfo *element_type_info;
-    GITypeTag element_type_tag;
-    element_type_info = g_type_info_get_param_type(type_info, 0);
-    element_type_tag = g_type_info_get_tag(element_type_info);
-    switch (element_type_tag) {
-    case GI_TYPE_TAG_VOID:
-    case GI_TYPE_TAG_BOOLEAN:
-    case GI_TYPE_TAG_INT8:
-    case GI_TYPE_TAG_UINT8:
-    case GI_TYPE_TAG_INT16:
-    case GI_TYPE_TAG_UINT16:
-    case GI_TYPE_TAG_INT32:
-    case GI_TYPE_TAG_UINT32:
-    case GI_TYPE_TAG_INT64:
-    case GI_TYPE_TAG_UINT64:
-    case GI_TYPE_TAG_FLOAT:
-    case GI_TYPE_TAG_DOUBLE:
-    case GI_TYPE_TAG_GTYPE:
-        g_base_info_unref(element_type_info);
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(GList)[%s] everything",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-    case GI_TYPE_TAG_UTF8:
-        g_base_info_unref(element_type_info);
-        g_list_foreach(argument->v_pointer, (GFunc)g_free, NULL);
-        g_list_free(argument->v_pointer);
-        break;
-    case GI_TYPE_TAG_FILENAME:
-    case GI_TYPE_TAG_ARRAY:
-        g_base_info_unref(element_type_info);
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(GList)[%s] everything",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-    case GI_TYPE_TAG_INTERFACE:
-        rb_gi_return_argument_free_everything_glist_interface(argument,
-                                                              type_info,
-                                                              element_type_info);
-        break;
-    case GI_TYPE_TAG_GLIST:
-    case GI_TYPE_TAG_GSLIST:
-    case GI_TYPE_TAG_GHASH:
-    case GI_TYPE_TAG_ERROR:
-    case GI_TYPE_TAG_UNICHAR:
-        g_base_info_unref(element_type_info);
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(GList)[%s] everything",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-    default:
-        g_base_info_unref(element_type_info);
-        g_assert_not_reached();
-        break;
-    }
-}
-static void
-rb_gi_return_argument_free_everything_gslist_interface(GIArgument *argument,
-                                                       G_GNUC_UNUSED GITypeInfo *type_info,
-                                                       GITypeInfo *element_type_info)
-{
-    GIBaseInfo *interface_info;
-    GIInfoType interface_type;
-    const gchar *interface_name;
-    GType gtype;
-    interface_info = g_type_info_get_interface(element_type_info);
-    interface_type = g_base_info_get_type(interface_info);
-    interface_name = g_info_type_to_string(interface_type);
-    gtype = g_registered_type_info_get_g_type(interface_info);
-    g_base_info_unref(interface_info);
-    g_base_info_unref(element_type_info);
-    switch (interface_type) {
-      case GI_INFO_TYPE_INVALID:
-      case GI_INFO_TYPE_FUNCTION:
-      case GI_INFO_TYPE_CALLBACK:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(GSList)[interface(%s)](%s) everything",
-                 interface_name,
-                 g_type_name(gtype));
-        break;
-      case GI_INFO_TYPE_STRUCT:
-        if (gtype == G_TYPE_NONE) {
-            rb_raise(rb_eNotImpError,
-                     "TODO: free GIArgument(GSList)[interface(%s)](%s) everything",
-                     interface_name,
-                     g_type_name(gtype));
-        } else {
-            g_slist_foreach(argument->v_pointer,
-                            rb_gi_boxed_free_callback,
-                            &gtype);
-            g_slist_free(argument->v_pointer);
-        }
-        break;
-      case GI_INFO_TYPE_BOXED:
-        g_slist_foreach(argument->v_pointer, rb_gi_boxed_free_callback, &gtype);
-        g_slist_free(argument->v_pointer);
-        break;
-      case GI_INFO_TYPE_ENUM:
-      case GI_INFO_TYPE_FLAGS:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(GSList)[interface(%s)](%s) everything",
-                 interface_name,
-                 g_type_name(gtype));
-        break;
-      case GI_INFO_TYPE_OBJECT:
-      case GI_INFO_TYPE_INTERFACE:
-        g_slist_foreach(argument->v_pointer, (GFunc)g_object_unref, NULL);
-        g_slist_free(argument->v_pointer);
-        break;
-      case GI_INFO_TYPE_CONSTANT:
-      case GI_INFO_TYPE_INVALID_0:
-      case GI_INFO_TYPE_UNION:
-      case GI_INFO_TYPE_VALUE:
-      case GI_INFO_TYPE_SIGNAL:
-      case GI_INFO_TYPE_VFUNC:
-      case GI_INFO_TYPE_PROPERTY:
-      case GI_INFO_TYPE_FIELD:
-      case GI_INFO_TYPE_ARG:
-      case GI_INFO_TYPE_TYPE:
-      case GI_INFO_TYPE_UNRESOLVED:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(GSList)[interface(%s)](%s) everything",
-                 interface_name,
-                 g_type_name(gtype));
-        break;
-      default:
-        g_assert_not_reached();
-        break;
-    }
-}
-static void
-rb_gi_return_argument_free_everything_gslist(GIArgument *argument,
-                                             GITypeInfo *type_info)
-{
-    GITypeInfo *element_type_info;
-    GITypeTag element_type_tag;
-    if (!argument->v_pointer)
-        return;
-    element_type_info = g_type_info_get_param_type(type_info, 0);
-    element_type_tag = g_type_info_get_tag(element_type_info);
-    switch (element_type_tag) {
-    case GI_TYPE_TAG_VOID:
-    case GI_TYPE_TAG_BOOLEAN:
-    case GI_TYPE_TAG_INT8:
-    case GI_TYPE_TAG_UINT8:
-    case GI_TYPE_TAG_INT16:
-    case GI_TYPE_TAG_UINT16:
-    case GI_TYPE_TAG_INT32:
-    case GI_TYPE_TAG_UINT32:
-    case GI_TYPE_TAG_INT64:
-    case GI_TYPE_TAG_UINT64:
-    case GI_TYPE_TAG_FLOAT:
-    case GI_TYPE_TAG_DOUBLE:
-    case GI_TYPE_TAG_GTYPE:
-        g_base_info_unref(element_type_info);
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(GSList)[%s] everything",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-    case GI_TYPE_TAG_UTF8:
-    case GI_TYPE_TAG_FILENAME:
-        g_base_info_unref(element_type_info);
-        g_slist_foreach(argument->v_pointer, (GFunc)g_free, NULL);
-        g_slist_free(argument->v_pointer);
-        break;
-    case GI_TYPE_TAG_ARRAY:
-        g_base_info_unref(element_type_info);
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(GSList)[%s] everything",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-    case GI_TYPE_TAG_INTERFACE:
-        rb_gi_return_argument_free_everything_gslist_interface(argument,
-                                                               type_info,
-                                                               element_type_info);
-        break;
-    case GI_TYPE_TAG_GLIST:
-    case GI_TYPE_TAG_GSLIST:
-    case GI_TYPE_TAG_GHASH:
-    case GI_TYPE_TAG_ERROR:
-    case GI_TYPE_TAG_UNICHAR:
-        g_base_info_unref(element_type_info);
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(GSList)[%s] everything",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-    default:
-        g_base_info_unref(element_type_info);
-        g_assert_not_reached();
-        break;
-    }
-}
-static void
-rb_gi_return_argument_free_everything(GIArgument *argument,
-                                      GITypeInfo *type_info)
-{
-    GITypeTag type_tag;
-    type_tag = g_type_info_get_tag(type_info);
-    switch (type_tag) {
-      case GI_TYPE_TAG_VOID:
-        break;
-      case GI_TYPE_TAG_BOOLEAN:
-      case GI_TYPE_TAG_INT8:
-      case GI_TYPE_TAG_UINT8:
-      case GI_TYPE_TAG_INT16:
-      case GI_TYPE_TAG_UINT16:
-      case GI_TYPE_TAG_INT32:
-      case GI_TYPE_TAG_UINT32:
-      case GI_TYPE_TAG_INT64:
-      case GI_TYPE_TAG_UINT64:
-      case GI_TYPE_TAG_FLOAT:
-      case GI_TYPE_TAG_DOUBLE:
-      case GI_TYPE_TAG_GTYPE:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(%s) everything",
-                 g_type_tag_to_string(type_tag));
-        break;
-      case GI_TYPE_TAG_UTF8:
-        g_free(argument->v_string);
-        break;
-      case GI_TYPE_TAG_FILENAME:
-        g_free(argument->v_string);
-        break;
-      case GI_TYPE_TAG_ARRAY:
-        rb_gi_return_argument_free_everything_array(argument, type_info);
-        break;
-      case GI_TYPE_TAG_INTERFACE:
-        rb_gi_return_argument_free_everything_interface(argument, type_info);
-        break;
-      case GI_TYPE_TAG_GLIST:
-        rb_gi_return_argument_free_everything_glist(argument, type_info);
-        break;
-      case GI_TYPE_TAG_GSLIST:
-        rb_gi_return_argument_free_everything_gslist(argument, type_info);
-        break;
-      case GI_TYPE_TAG_GHASH:
-        g_hash_table_unref(argument->v_pointer);
-        break;
-      case GI_TYPE_TAG_ERROR:
-      case GI_TYPE_TAG_UNICHAR:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(%s) everything",
-                 g_type_tag_to_string(type_tag));
-        break;
-      default:
-        g_assert_not_reached();
-        break;
-    }
-}
-VALUE
-rb_gi_return_argument_to_ruby(GICallableInfo *callable_info,
-                              GIArgument *argument,
-                              GArray *in_args,
-                              GArray *out_args,
-                              GPtrArray *args_metadata)
-{
-    VALUE rb_argument;
-    gboolean may_return_null;
-    GITypeInfo return_value_info;
-    may_return_null = g_callable_info_may_return_null(callable_info);
-    if (may_return_null && !argument->v_pointer) {
-        return Qnil;
-    }
-    g_callable_info_load_return_type(callable_info, &return_value_info);
-    rb_argument = rb_gi_argument_to_ruby(argument, FALSE, &return_value_info,
-                                         in_args, out_args, args_metadata);
-    switch (g_callable_info_get_caller_owns(callable_info)) {
-    case GI_TRANSFER_NOTHING:
-        break;
-    case GI_TRANSFER_CONTAINER:
-        rb_gi_return_argument_free_container(argument, &return_value_info);
-        break;
-    case GI_TRANSFER_EVERYTHING:
-        rb_gi_return_argument_free_everything(argument, &return_value_info);
-        break;
-    default:
-        g_assert_not_reached();
-        break;
-    }
-    return rb_argument;
-}
-static void
-rb_gi_value_argument_from_ruby_interface(GIArgument *argument,
-                                         GITypeInfo *type_info,
-                                         VALUE rb_argument,
-                                         VALUE self)
-{
-    GIBaseInfo *interface_info;
-    GIInfoType interface_type;
-    GType gtype;
-    interface_info = g_type_info_get_interface(type_info);
-    interface_type = g_base_info_get_type(interface_info);
-    switch (interface_type) {
-    case GI_INFO_TYPE_INVALID:
-    case GI_INFO_TYPE_FUNCTION:
-    case GI_INFO_TYPE_CALLBACK:
-        rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(interface)[%s]: <%s>",
-                 g_info_type_to_string(interface_type),
-                 g_base_info_get_name(interface_info));
-        break;
-    case GI_INFO_TYPE_STRUCT:
-        gtype = g_registered_type_info_get_g_type(interface_info);
-        if (gtype == G_TYPE_NONE) {
-            argument->v_pointer = rb_gi_struct_get_raw(rb_argument, gtype);
-        } else if (gtype == G_TYPE_VALUE) {
-            GValue *gvalue;
-            if (RVAL2CBOOL(rb_obj_is_kind_of(rb_argument, rb_cGLibValue))) {
-                gvalue = RVAL2BOXED(rb_argument, G_TYPE_VALUE);
-            } else {
-                gvalue = ALLOC(GValue);
-                memset(gvalue, 0, sizeof(GValue));
-                rbgobj_initialize_gvalue(gvalue, rb_argument);
-            }
-            argument->v_pointer = gvalue;
-        } else if (gtype == G_TYPE_BYTES) {
-            if (RVAL2CBOOL(rb_obj_is_kind_of(rb_argument, rb_cGLibBytes))) {
-                argument->v_pointer = RVAL2BOXED(rb_argument, G_TYPE_BYTES);
-                g_bytes_ref(argument->v_pointer);
-            } else {
-                VALUE rb_string;
-                GBytes *gbytes;
-                rb_string = StringValue(rb_argument);
-                gbytes = g_bytes_new(RSTRING_PTR(rb_string),
-                                     RSTRING_LEN(rb_string));
-                argument->v_pointer = gbytes;
-            }
-        } else if (gtype == G_TYPE_CLOSURE) {
-            GClosure *rclosure = NULL;
-            rclosure = g_rclosure_new(rb_argument, Qnil, NULL);
-            g_rclosure_attach(rclosure, self);
-            argument->v_pointer = rclosure;
-        } else if (gtype == G_TYPE_VARIANT) {
-            argument->v_pointer = rbg_variant_from_ruby(rb_argument);
-        } else {
-            argument->v_pointer = RVAL2BOXED(rb_argument, gtype);
-        }
-        break;
-    case GI_INFO_TYPE_BOXED:
-        rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(interface)[%s]: <%s>",
-                 g_info_type_to_string(interface_type),
-                 g_base_info_get_name(interface_info));
-        break;
-    case GI_INFO_TYPE_ENUM:
-        gtype = g_registered_type_info_get_g_type(interface_info);
-        if (gtype == G_TYPE_NONE) {
-            argument->v_int32 = NUM2INT(rb_argument);
-        } else {
-            argument->v_int32 = RVAL2GENUM(rb_argument, gtype);
-        }
-        break;
-    case GI_INFO_TYPE_FLAGS:
-        gtype = g_registered_type_info_get_g_type(interface_info);
-        if (gtype == G_TYPE_NONE) {
-            argument->v_int32 = NUM2INT(rb_argument);
-        } else {
-            argument->v_int32 = RVAL2GFLAGS(rb_argument, gtype);
-        }
-        break;
-    case GI_INFO_TYPE_OBJECT:
-    case GI_INFO_TYPE_INTERFACE:
-        gtype = g_registered_type_info_get_g_type(interface_info);
-        argument->v_pointer = RVAL2GOBJ(rb_argument);
-        if (argument->v_pointer &&
-            gtype != G_TYPE_NONE &&
-            !G_TYPE_CHECK_INSTANCE_TYPE(argument->v_pointer, gtype)) {
-            rb_raise(rb_eArgError,
-                     "must be <%s> object: <%" PRIsVALUE ">",
-                     g_type_name(gtype),
-                     rb_argument);
-        }
-        break;
-    case GI_INFO_TYPE_CONSTANT:
-        rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(interface)[%s]: <%s>",
-                 g_info_type_to_string(interface_type),
-                 g_base_info_get_name(interface_info));
-        break;
-    case GI_INFO_TYPE_INVALID_0:
-        g_assert_not_reached();
-        break;
-    case GI_INFO_TYPE_UNION:
-        gtype = g_registered_type_info_get_g_type(interface_info);
-        if (gtype == G_TYPE_NONE) {
-            rb_raise(rb_eNotImpError,
-                     "TODO: Ruby -> GIArgument(interface)[%s]: <%s>"
-                     "(G_TYPE_NONE)",
-                     g_info_type_to_string(interface_type),
-                     g_base_info_get_name(interface_info));
-        } else {
-            argument->v_pointer = RVAL2BOXED(rb_argument, gtype);
-        }
-        break;
-    case GI_INFO_TYPE_VALUE:
-    case GI_INFO_TYPE_SIGNAL:
-    case GI_INFO_TYPE_VFUNC:
-    case GI_INFO_TYPE_PROPERTY:
-    case GI_INFO_TYPE_FIELD:
-    case GI_INFO_TYPE_ARG:
-    case GI_INFO_TYPE_TYPE:
-    case GI_INFO_TYPE_UNRESOLVED:
-    default:
-        rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(interface)[%s]: <%s>",
-                 g_info_type_to_string(interface_type),
-                 g_base_info_get_name(interface_info));
-        break;
-    }
-    g_base_info_unref(interface_info);
-}
-static void
-rb_gi_value_argument_from_ruby_glist(GIArgument *argument,
-                                     GITypeInfo *type_info,
-                                     VALUE rb_argument,
-                                     G_GNUC_UNUSED VALUE self)
-{
-    GITypeInfo *element_type_info;
-    GITypeTag element_type_tag;
-    GType gtype = G_TYPE_NONE;
-    element_type_info = g_type_info_get_param_type(type_info, 0);
-    element_type_tag = g_type_info_get_tag(element_type_info);
-    if (element_type_tag == GI_TYPE_TAG_INTERFACE) {
-        GIBaseInfo *interface_info;
-        interface_info = g_type_info_get_interface(element_type_info);
-        gtype = g_registered_type_info_get_g_type(interface_info);
-        g_base_info_unref(interface_info);
-    }
-    g_base_info_unref(element_type_info);
-    switch (element_type_tag) {
-    case GI_TYPE_TAG_VOID:
-    case GI_TYPE_TAG_BOOLEAN:
-    case GI_TYPE_TAG_INT8:
-    case GI_TYPE_TAG_UINT8:
-    case GI_TYPE_TAG_INT16:
-    case GI_TYPE_TAG_UINT16:
-    case GI_TYPE_TAG_INT32:
-    case GI_TYPE_TAG_UINT32:
-    case GI_TYPE_TAG_INT64:
-    case GI_TYPE_TAG_UINT64:
-    case GI_TYPE_TAG_FLOAT:
-    case GI_TYPE_TAG_DOUBLE:
-    case GI_TYPE_TAG_GTYPE:
-    case GI_TYPE_TAG_UTF8:
-    case GI_TYPE_TAG_FILENAME:
-    case GI_TYPE_TAG_ARRAY:
-        rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(GList)[%s]",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-    case GI_TYPE_TAG_INTERFACE:
-        argument->v_pointer = RVAL2GOBJGLIST(rb_argument);
-        if (gtype != G_TYPE_NONE) {
-            GList *node;
-            for (node = argument->v_pointer; node; node = g_list_next(node)) {
-                GObject *object = node->data;
-                if (!G_TYPE_CHECK_INSTANCE_TYPE(object, gtype)) {
-                    g_list_free(argument->v_pointer);
-                    rb_raise(rb_eArgError,
-                             "must be <%s> objects: <%" PRIsVALUE ">",
-                             g_type_name(gtype),
-                             rb_argument);
-                }
-            }
-        }
-        break;
-    case GI_TYPE_TAG_GLIST:
-    case GI_TYPE_TAG_GSLIST:
-    case GI_TYPE_TAG_GHASH:
-    case GI_TYPE_TAG_ERROR:
-    case GI_TYPE_TAG_UNICHAR:
-        rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(GList)[%s]",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-    default:
-        g_assert_not_reached();
-        break;
-    }
-}
-static void
-rb_gi_value_argument_from_ruby_gslist(GIArgument *argument,
-                                      GITypeInfo *type_info,
-                                      VALUE rb_argument,
-                                      G_GNUC_UNUSED VALUE self)
-{
-    GITypeInfo *element_type_info;
-    GITypeTag element_type_tag;
-    GType gtype = G_TYPE_NONE;
-    element_type_info = g_type_info_get_param_type(type_info, 0);
-    element_type_tag = g_type_info_get_tag(element_type_info);
-    if (element_type_tag == GI_TYPE_TAG_INTERFACE) {
-        GIBaseInfo *interface_info;
-        interface_info = g_type_info_get_interface(element_type_info);
-        gtype = g_registered_type_info_get_g_type(interface_info);
-        g_base_info_unref(interface_info);
-    }
-    g_base_info_unref(element_type_info);
-    switch (element_type_tag) {
-    case GI_TYPE_TAG_VOID:
-    case GI_TYPE_TAG_BOOLEAN:
-    case GI_TYPE_TAG_INT8:
-    case GI_TYPE_TAG_UINT8:
-    case GI_TYPE_TAG_INT16:
-    case GI_TYPE_TAG_UINT16:
-    case GI_TYPE_TAG_INT32:
-    case GI_TYPE_TAG_UINT32:
-    case GI_TYPE_TAG_INT64:
-    case GI_TYPE_TAG_UINT64:
-    case GI_TYPE_TAG_FLOAT:
-    case GI_TYPE_TAG_DOUBLE:
-    case GI_TYPE_TAG_GTYPE:
-    case GI_TYPE_TAG_UTF8:
-    case GI_TYPE_TAG_FILENAME:
-    case GI_TYPE_TAG_ARRAY:
-        rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(GSList)[%s]",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-    case GI_TYPE_TAG_INTERFACE:
-        argument->v_pointer = RVAL2GOBJGSLIST(rb_argument);
-        if (gtype != G_TYPE_NONE) {
-            GSList *node;
-            for (node = argument->v_pointer; node; node = g_slist_next(node)) {
-                GObject *object = node->data;
-                if (!G_TYPE_CHECK_INSTANCE_TYPE(object, gtype)) {
-                    g_slist_free(argument->v_pointer);
-                    rb_raise(rb_eArgError,
-                             "must be <%s> objects: <%" PRIsVALUE ">",
-                             g_type_name(gtype),
-                             rb_argument);
-                }
-            }
-        }
-        break;
-    case GI_TYPE_TAG_GLIST:
-    case GI_TYPE_TAG_GSLIST:
-    case GI_TYPE_TAG_GHASH:
-    case GI_TYPE_TAG_ERROR:
-    case GI_TYPE_TAG_UNICHAR:
-        rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(GSList)[%s]",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-    default:
-        g_assert_not_reached();
-        break;
-    }
-}
-typedef struct {
-    VALUE rb_value;
-    GType gtype;
-    const gchar *context;
-} RubyToCData;
-typedef gpointer (*RubyToCFunc)(RubyToCData *data);
-static gpointer
-ruby_to_c_utf8(RubyToCData *data)
-{
-    return g_strdup(RVAL2CSTR(data->rb_value));
-}
-static gpointer
-ruby_to_c_interface_enum(RubyToCData *data)
-{
-    gint32 value;
-    if (data->gtype == G_TYPE_NONE) {
-        value = NUM2INT(data->rb_value);
-    } else {
-        value = RVAL2GENUM(data->rb_value, data->gtype);
-    }
-    return GINT_TO_POINTER(value);
-}
-typedef struct {
-    GIArgument *argument;
-    GITypeInfo *type_info;
-    VALUE rb_argument;
-    VALUE self;
-} ArgumentFromRubyData;
-typedef struct {
-    GHashTable *hash_table;
-    RubyToCFunc key_ruby_to_c_func;
-    RubyToCData *key_ruby_to_c_data;
-    RubyToCFunc value_ruby_to_c_func;
-    RubyToCData *value_ruby_to_c_data;
-} ArgumentFromRubyGHashData;
-static int
-rb_gi_value_argument_from_ruby_ghash_convert(VALUE rb_key,
-                                             VALUE rb_value,
-                                             VALUE user_data)
-{
-    ArgumentFromRubyGHashData *data = (ArgumentFromRubyGHashData *)user_data;
-    gpointer key;
-    gpointer value;
-    data->key_ruby_to_c_data->rb_value = rb_key;
-    key = data->key_ruby_to_c_func(data->key_ruby_to_c_data);
-    data->value_ruby_to_c_data->rb_value = rb_value;
-    value = data->key_ruby_to_c_func(data->value_ruby_to_c_data);
-    g_hash_table_insert(data->hash_table, key, value);
-    return ST_CONTINUE;
-}
-static VALUE
-rb_gi_value_argument_from_ruby_ghash_body(VALUE value_data)
-{
-    ArgumentFromRubyData *data = (ArgumentFromRubyData *)value_data;
-    GIArgument *argument = data->argument;
-    GITypeInfo *type_info = data->type_info;
-    VALUE rb_argument = data->rb_argument;
-    GHashFunc hash_func = NULL;
-    GEqualFunc equal_func = NULL;
-    GDestroyNotify key_destroy_func = NULL;
-    GDestroyNotify value_destroy_func = NULL;
-    GITypeInfo *key_type_info;
-    GITypeTag key_type_tag;
-    GIInfoType key_interface_type = GI_INFO_TYPE_INVALID;
-    RubyToCFunc key_ruby_to_c_func = NULL;
-    RubyToCData key_ruby_to_c_data;
-    GITypeInfo *value_type_info;
-    GITypeTag value_type_tag;
-    GIInfoType value_interface_type = GI_INFO_TYPE_INVALID;
-    RubyToCFunc value_ruby_to_c_func = NULL;
-    RubyToCData value_ruby_to_c_data;
-    ArgumentFromRubyGHashData convert_data;
-    key_type_info = g_type_info_get_param_type(type_info, 0);
-    key_type_tag = g_type_info_get_tag(key_type_info);
-    key_ruby_to_c_data.gtype = G_TYPE_NONE;
-    if (key_type_tag == GI_TYPE_TAG_INTERFACE) {
-        GIBaseInfo *interface_info;
-        interface_info = g_type_info_get_interface(key_type_info);
-        key_ruby_to_c_data.gtype =
-            g_registered_type_info_get_g_type(interface_info);
-        key_interface_type = g_base_info_get_type(interface_info);
-        g_base_info_unref(interface_info);
-    }
-    g_base_info_unref(key_type_info);
-    value_type_info = g_type_info_get_param_type(type_info, 1);
-    value_type_tag = g_type_info_get_tag(value_type_info);
-    value_ruby_to_c_data.gtype = G_TYPE_NONE;
-    if (value_type_tag == GI_TYPE_TAG_INTERFACE) {
-        GIBaseInfo *interface_info;
-        interface_info = g_type_info_get_interface(value_type_info);
-        value_ruby_to_c_data.gtype =
-            g_registered_type_info_get_g_type(interface_info);
-        value_interface_type = g_base_info_get_type(interface_info);
-        g_base_info_unref(interface_info);
-    }
-    g_base_info_unref(value_type_info);
-    switch (key_type_tag) {
-      case GI_TYPE_TAG_VOID:
-      case GI_TYPE_TAG_BOOLEAN:
-      case GI_TYPE_TAG_INT8:
-      case GI_TYPE_TAG_UINT8:
-      case GI_TYPE_TAG_INT16:
-      case GI_TYPE_TAG_UINT16:
-      case GI_TYPE_TAG_INT32:
-      case GI_TYPE_TAG_UINT32:
-      case GI_TYPE_TAG_INT64:
-      case GI_TYPE_TAG_UINT64:
-      case GI_TYPE_TAG_FLOAT:
-      case GI_TYPE_TAG_DOUBLE:
-      case GI_TYPE_TAG_GTYPE:
-        rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(GHash)[key][%s]",
-                 g_type_tag_to_string(key_type_tag));
-        break;
-      case GI_TYPE_TAG_UTF8:
-        hash_func = g_str_hash;
-        equal_func = g_str_equal;
-        key_destroy_func = g_free;
-        key_ruby_to_c_func = ruby_to_c_utf8;
-        key_ruby_to_c_data.context = "Ruby -> GIArgument(GHash)[key][utf8]";
-        break;
-      case GI_TYPE_TAG_FILENAME:
-      case GI_TYPE_TAG_ARRAY:
-      case GI_TYPE_TAG_INTERFACE:
-      case GI_TYPE_TAG_GLIST:
-      case GI_TYPE_TAG_GSLIST:
-      case GI_TYPE_TAG_GHASH:
-      case GI_TYPE_TAG_ERROR:
-      case GI_TYPE_TAG_UNICHAR:
-        rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(GHash)[key][%s]",
-                 g_type_tag_to_string(key_type_tag));
-        break;
-      default:
-        g_assert_not_reached();
-        break;
-    }
-    switch (value_type_tag) {
-      case GI_TYPE_TAG_VOID:
-      case GI_TYPE_TAG_BOOLEAN:
-      case GI_TYPE_TAG_INT8:
-      case GI_TYPE_TAG_UINT8:
-      case GI_TYPE_TAG_INT16:
-      case GI_TYPE_TAG_UINT16:
-      case GI_TYPE_TAG_INT32:
-      case GI_TYPE_TAG_UINT32:
-      case GI_TYPE_TAG_INT64:
-      case GI_TYPE_TAG_UINT64:
-      case GI_TYPE_TAG_FLOAT:
-      case GI_TYPE_TAG_DOUBLE:
-      case GI_TYPE_TAG_GTYPE:
-      case GI_TYPE_TAG_UTF8:
-      case GI_TYPE_TAG_FILENAME:
-      case GI_TYPE_TAG_ARRAY:
-        rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(GHash)[value][%s]",
-                 g_type_tag_to_string(value_type_tag));
-        break;
-      case GI_TYPE_TAG_INTERFACE:
-        switch (value_interface_type) {
-          case GI_INFO_TYPE_INVALID:
-          case GI_INFO_TYPE_FUNCTION:
-          case GI_INFO_TYPE_CALLBACK:
-          case GI_INFO_TYPE_STRUCT:
-          case GI_INFO_TYPE_BOXED:
-            rb_raise(rb_eNotImpError,
-                     "TODO: Ruby -> GIArgument(GHash)[value][%s][%s]",
-                     g_type_tag_to_string(value_type_tag),
-                     g_info_type_to_string(value_interface_type));
-            break;
-          case GI_INFO_TYPE_ENUM:
-            value_destroy_func = NULL;
-            value_ruby_to_c_func = ruby_to_c_interface_enum;
-            value_ruby_to_c_data.context =
-                "Ruby -> GIArgument(GHash)[value][interface]";
-            break;
-          case GI_INFO_TYPE_FLAGS:
-          case GI_INFO_TYPE_OBJECT:
-          case GI_INFO_TYPE_INTERFACE:
-          case GI_INFO_TYPE_CONSTANT:
-          case GI_INFO_TYPE_INVALID_0:
-          case GI_INFO_TYPE_UNION:
-          case GI_INFO_TYPE_VALUE:
-          case GI_INFO_TYPE_SIGNAL:
-          case GI_INFO_TYPE_VFUNC:
-          case GI_INFO_TYPE_PROPERTY:
-          case GI_INFO_TYPE_FIELD:
-          case GI_INFO_TYPE_ARG:
-          case GI_INFO_TYPE_TYPE:
-          case GI_INFO_TYPE_UNRESOLVED:
-            rb_raise(rb_eNotImpError,
-                     "TODO: Ruby -> GIArgument(GHash)[value][%s][%s]",
-                     g_type_tag_to_string(value_type_tag),
-                     g_info_type_to_string(value_interface_type));
-            break;
-          default:
-            g_assert_not_reached();
-            break;
-        }
-        break;
-      case GI_TYPE_TAG_GLIST:
-      case GI_TYPE_TAG_GSLIST:
-      case GI_TYPE_TAG_GHASH:
-      case GI_TYPE_TAG_ERROR:
-      case GI_TYPE_TAG_UNICHAR:
-        rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(GHash)[value][%s]",
-                 g_type_tag_to_string(value_type_tag));
-        break;
-      default:
-        g_assert_not_reached();
-        break;
-    }
-    argument->v_pointer = g_hash_table_new_full(hash_func,
-                                                equal_func,
-                                                key_destroy_func,
-                                                value_destroy_func);
-    convert_data.hash_table = argument->v_pointer;
-    convert_data.key_ruby_to_c_func = key_ruby_to_c_func;
-    convert_data.key_ruby_to_c_data = &key_ruby_to_c_data;
-    convert_data.value_ruby_to_c_func = value_ruby_to_c_func;
-    convert_data.value_ruby_to_c_data = &value_ruby_to_c_data;
-    rb_hash_foreach(rb_argument,
-                    rb_gi_value_argument_from_ruby_ghash_convert,
-                    (VALUE)&convert_data);
-    return Qnil;
-}
-static VALUE
-rb_gi_value_argument_from_ruby_ghash_rescue(VALUE value_data,
-                                            VALUE exception)
-{
-    ArgumentFromRubyData *data = (ArgumentFromRubyData *)value_data;
-    GIArgument *argument = data->argument;
-    if (argument->v_pointer) {
-        g_hash_table_unref(argument->v_pointer);
-        argument->v_pointer = NULL;
-    }
-    rb_exc_raise(exception);
-    return Qnil;
-}
-static void
-rb_gi_value_argument_from_ruby_ghash(GIArgument *argument,
-                                     GITypeInfo *type_info,
-                                     VALUE rb_argument,
-                                     VALUE self)
-{
-    ArgumentFromRubyData data;
-    argument->v_pointer = NULL;
-    data.argument = argument;
-    data.type_info = type_info;
-    data.rb_argument = rb_argument;
-    data.self = self;
-    rb_rescue(rb_gi_value_argument_from_ruby_ghash_body, (VALUE)&data,
-              rb_gi_value_argument_from_ruby_ghash_rescue, (VALUE)&data);
-}
-static void
-rb_gi_value_argument_from_ruby_void(GIArgument *argument, GITypeInfo *type_info,
-                                    VALUE rb_argument)
-{
-    if (!g_type_info_is_pointer(type_info)) {
-        return;
-    }
-    if (RB_TYPE_P(rb_argument, RUBY_T_STRING)) {
-        argument->v_pointer = RSTRING_PTR(rb_argument);
-    } else if (RVAL2CBOOL(rb_obj_is_kind_of(rb_argument, rb_cGLibObject))) {
-        argument->v_pointer = RVAL2GOBJ(rb_argument);
-    } else {
-        argument->v_pointer = GUINT_TO_POINTER(NUM2ULONG(rb_argument));
-    }
-}
-static GType
-rb_gi_value_argument_from_ruby_gtype(VALUE rb_argument)
-{
-    ID id_gtype;
-    VALUE rb_gtype;
-    if (RB_TYPE_P(rb_argument, RUBY_T_STRING)) {
-        GType gtype;
-        gtype = g_type_from_name(RVAL2CSTR(rb_argument));
-        if (gtype == 0) {
-            rb_raise(rb_eArgError,
-                     "unknown GType name: <%s>",
-                     RVAL2CSTR(rb_argument));
-        }
-        return gtype;
-    }
-    CONST_ID(id_gtype, "gtype");
-    if (rb_respond_to(rb_argument, id_gtype)) {
-        rb_gtype = rb_funcall(rb_argument, id_gtype, 0);
-    } else {
-        rb_gtype = rb_argument;
-    }
-    return NUM2ULONG(rb_gtype);
-}
-GIArgument *
-rb_gi_value_argument_from_ruby(GIArgument *argument, GITypeInfo *type_info,
-                               VALUE rb_argument, VALUE self)
-{
-    GITypeTag type_tag;
-    memset(argument, 0, sizeof(GIArgument));
-    type_tag = g_type_info_get_tag(type_info);
-    switch (type_tag) {
-    case GI_TYPE_TAG_VOID:
-        rb_gi_value_argument_from_ruby_void(argument, type_info, rb_argument);
-        break;
-    case GI_TYPE_TAG_BOOLEAN:
-        argument->v_boolean = RVAL2CBOOL(rb_argument);
-        break;
-    case GI_TYPE_TAG_INT8:
-        argument->v_int8 = NUM2CHR(rb_argument);
-        break;
-    case GI_TYPE_TAG_UINT8:
-        argument->v_uint8 = (guint8)NUM2CHR(rb_argument);
-        break;
-    case GI_TYPE_TAG_INT16:
-        argument->v_int16 = NUM2SHORT(rb_argument);
-        break;
-    case GI_TYPE_TAG_UINT16:
-        argument->v_uint16 = NUM2USHORT(rb_argument);
-        break;
-    case GI_TYPE_TAG_INT32:
-        argument->v_int32 = NUM2INT(rb_argument);
-        break;
-    case GI_TYPE_TAG_UINT32:
-        argument->v_uint32 = NUM2UINT(rb_argument);
-        break;
-    case GI_TYPE_TAG_INT64:
-        argument->v_int64 = NUM2LL(rb_argument);
-        break;
-    case GI_TYPE_TAG_UINT64:
-        argument->v_uint64 = NUM2ULL(rb_argument);
-        break;
-    case GI_TYPE_TAG_FLOAT:
-        argument->v_float = NUM2DBL(rb_argument);
-        break;
-    case GI_TYPE_TAG_DOUBLE:
-        argument->v_double = NUM2DBL(rb_argument);
-        break;
-    case GI_TYPE_TAG_GTYPE:
-        argument->v_size = rb_gi_value_argument_from_ruby_gtype(rb_argument);
-        break;
-    case GI_TYPE_TAG_UTF8:
-        /* TODO: support UTF-8 convert like rb_argument.encode("UTF-8"). */
-        argument->v_string = (gchar *)RVAL2CSTR_ACCEPT_SYMBOL(rb_argument);
-        break;
-    case GI_TYPE_TAG_FILENAME:
-        argument->v_string = (gchar *)RVAL2CSTR(rb_argument);
-        break;
-    case GI_TYPE_TAG_ARRAY:
-        rb_raise(rb_eNotImpError,
-                 "should not be reached: Ruby -> GIArgument(%s)",
-                 g_type_tag_to_string(type_tag));
-        break;
-    case GI_TYPE_TAG_INTERFACE:
-        rb_gi_value_argument_from_ruby_interface(argument, type_info,
-                                                 rb_argument, self);
-        break;
-    case GI_TYPE_TAG_GLIST:
-        rb_gi_value_argument_from_ruby_glist(argument, type_info,
-                                             rb_argument, self);
-        break;
-    case GI_TYPE_TAG_GSLIST:
-        rb_gi_value_argument_from_ruby_gslist(argument, type_info,
-                                              rb_argument, self);
-        break;
-    case GI_TYPE_TAG_GHASH:
-        rb_gi_value_argument_from_ruby_ghash(argument, type_info,
-                                             rb_argument, self);
-        break;
-    case GI_TYPE_TAG_ERROR:
-        rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(%s)",
-                 g_type_tag_to_string(type_tag));
-        break;
-    case GI_TYPE_TAG_UNICHAR:
-      if (NIL_P(rb_argument)) {
-          argument->v_uint32 = 0;
-      } else {
-          argument->v_uint32 = NUM2UINT(rb_argument);
-      }
-      break;
-    default:
-        g_assert_not_reached();
-        break;
-    }
-    return argument;
-}
-static void
-rb_gi_inout_argument_from_ruby(GIArgument *argument,
-                               G_GNUC_UNUSED GIArgInfo *arg_info,
-                               GITypeInfo *type_info,
-                               VALUE rb_argument,
-                               VALUE self)
-{
-    GIArgument in_argument;
-    GITypeTag type_tag;
-    rb_gi_value_argument_from_ruby(&in_argument, type_info, rb_argument, self);
-    type_tag = g_type_info_get_tag(type_info);
-    switch (type_tag) {
-    case GI_TYPE_TAG_VOID:
-        break;
-    case GI_TYPE_TAG_BOOLEAN:
-        argument->v_pointer = ALLOC(gboolean);
-        *((gboolean *)argument->v_pointer) = in_argument.v_boolean;
-        break;
-    case GI_TYPE_TAG_INT8:
-        argument->v_pointer = ALLOC(gint8);
-        *((gint8 *)argument->v_pointer) = in_argument.v_int8;
-        break;
-    case GI_TYPE_TAG_UINT8:
-        argument->v_pointer = ALLOC(guint8);
-        *((guint8 *)argument->v_pointer) = in_argument.v_uint8;
-        break;
-    case GI_TYPE_TAG_INT16:
-        argument->v_pointer = ALLOC(gint16);
-        *((gint16 *)argument->v_pointer) = in_argument.v_int16;
-        break;
-    case GI_TYPE_TAG_UINT16:
-        argument->v_pointer = ALLOC(guint16);
-        *((guint16 *)argument->v_pointer) = in_argument.v_uint16;
-        break;
-    case GI_TYPE_TAG_INT32:
-        argument->v_pointer = ALLOC(gint32);
-        *((gint32 *)argument->v_pointer) = in_argument.v_int32;
-        break;
-    case GI_TYPE_TAG_UINT32:
-        argument->v_pointer = ALLOC(guint32);
-        *((guint32 *)argument->v_pointer) = in_argument.v_uint32;
-        break;
-    case GI_TYPE_TAG_INT64:
-        argument->v_pointer = ALLOC(gint64);
-        *((gint64 *)argument->v_pointer) = in_argument.v_int64;
-        break;
-    case GI_TYPE_TAG_UINT64:
-        argument->v_pointer = ALLOC(guint64);
-        *((guint64 *)argument->v_pointer) = in_argument.v_uint64;
-        break;
-    case GI_TYPE_TAG_FLOAT:
-        argument->v_pointer = ALLOC(gfloat);
-        *((gfloat *)argument->v_pointer) = in_argument.v_float;
-        break;
-    case GI_TYPE_TAG_DOUBLE:
-        argument->v_pointer = ALLOC(gdouble);
-        *((gdouble *)argument->v_pointer) = in_argument.v_double;
-        break;
-    case GI_TYPE_TAG_GTYPE:
-        argument->v_pointer = ALLOC(gsize);
-        *((gsize *)argument->v_pointer) = in_argument.v_size;
-        break;
-    case GI_TYPE_TAG_UTF8:
-    case GI_TYPE_TAG_FILENAME:
-        argument->v_pointer = ALLOC(gchar *);
-        *((gchar **)argument->v_pointer) = in_argument.v_string;
-        break;
-    case GI_TYPE_TAG_ARRAY:
-        rb_raise(rb_eNotImpError,
-                 "should not be reached: Ruby -> GIArgument(%s)",
-                 g_type_tag_to_string(type_tag));
-        break;
-    case GI_TYPE_TAG_INTERFACE:
-    case GI_TYPE_TAG_GLIST:
-    case GI_TYPE_TAG_GSLIST:
-    case GI_TYPE_TAG_GHASH:
-        argument->v_pointer = ALLOC(gpointer);
-        *((gpointer *)argument->v_pointer) = in_argument.v_pointer;
-        break;
-    case GI_TYPE_TAG_ERROR:
-        argument->v_pointer = ALLOC(GError *);
-        *((GError **)argument->v_pointer) = in_argument.v_pointer;
-        break;
-    case GI_TYPE_TAG_UNICHAR:
-        argument->v_pointer = ALLOC(gunichar);
-        *((gunichar *)argument->v_pointer) = in_argument.v_uint32;
-        break;
-    default:
-        g_assert_not_reached();
-        break;
-    }
-}
-static void
-rb_gi_in_argument_transfer_interface(GIArgument *argument,
-                                     G_GNUC_UNUSED GITransfer transfer,
-                                     GITypeInfo *type_info,
-                                     VALUE rb_argument)
-{
-    GIBaseInfo *interface_info;
-    GIInfoType interface_type;
-    G_GNUC_UNUSED GType gtype;
-    interface_info = g_type_info_get_interface(type_info);
-    interface_type = g_base_info_get_type(interface_info);
-    gtype = g_registered_type_info_get_g_type(interface_info);
-    g_base_info_unref(interface_info);
-    switch (interface_type) {
-    case GI_INFO_TYPE_INVALID:
-    case GI_INFO_TYPE_FUNCTION:
-    case GI_INFO_TYPE_CALLBACK:
-        rb_raise(rb_eNotImpError,
-                 "TODO: in transfer (interface) [%s]",
-                 g_info_type_to_string(interface_type));
-        break;
-    case GI_INFO_TYPE_STRUCT:
-        rbgobj_boxed_unown(rb_argument);
-        break;
-    case GI_INFO_TYPE_BOXED:
-    case GI_INFO_TYPE_ENUM:
-    case GI_INFO_TYPE_FLAGS:
-        rb_raise(rb_eNotImpError,
-                 "TODO: in transfer (interface) [%s]",
-                 g_info_type_to_string(interface_type));
-        break;
-    case GI_INFO_TYPE_OBJECT:
-        g_object_ref(argument->v_pointer);
+        if (argument->v_pointer) {
+            GObject *object = argument->v_pointer;
+            if (g_object_is_floating(object)) {
+                g_object_ref_sink(object);
+            }
+            g_object_unref(object);
+        }
         break;
     case GI_INFO_TYPE_INTERFACE:
+        if (argument->v_pointer) {
+            g_object_unref(argument->v_pointer);
+        }
+        break;
     case GI_INFO_TYPE_CONSTANT:
         rb_raise(rb_eNotImpError,
-                 "TODO: in transfer (interface) [%s]",
-                 g_info_type_to_string(interface_type));
+                 "TODO: free GIArgument(interface)[constant] everything");
         break;
     case GI_INFO_TYPE_INVALID_0:
         g_assert_not_reached();
         break;
     case GI_INFO_TYPE_UNION:
+      if (gtype == G_TYPE_NONE) {
+          rb_raise(rb_eNotImpError,
+                   "TODO: free GIArgument(interface)[union] everything");
+      } else {
+          g_boxed_free(gtype, argument->v_pointer);
+      }
+      break;
     case GI_INFO_TYPE_VALUE:
-    case GI_INFO_TYPE_SIGNAL:
-    case GI_INFO_TYPE_VFUNC:
-    case GI_INFO_TYPE_PROPERTY:
-    case GI_INFO_TYPE_FIELD:
-    case GI_INFO_TYPE_ARG:
-    case GI_INFO_TYPE_TYPE:
-    case GI_INFO_TYPE_UNRESOLVED:
-        rb_raise(rb_eNotImpError,
-                 "TODO: in transfer (interface) [%s]",
-                 g_info_type_to_string(interface_type));
-        break;
-    default:
-        g_assert_not_reached();
-        break;
-    }
-}
-static void
-rb_gi_in_argument_transfer(GIArgument *argument, GITransfer transfer,
-                           GITypeInfo *type_info, VALUE rb_argument)
-{
-    GITypeTag type_tag;
-    if (transfer == GI_TRANSFER_NOTHING) {
-        return;
-    }
-    type_tag = g_type_info_get_tag(type_info);
-    switch (type_tag) {
-    case GI_TYPE_TAG_VOID:
-    case GI_TYPE_TAG_BOOLEAN:
-    case GI_TYPE_TAG_INT8:
-    case GI_TYPE_TAG_UINT8:
-    case GI_TYPE_TAG_INT16:
-    case GI_TYPE_TAG_UINT16:
-    case GI_TYPE_TAG_INT32:
-    case GI_TYPE_TAG_UINT32:
-    case GI_TYPE_TAG_INT64:
-    case GI_TYPE_TAG_UINT64:
-    case GI_TYPE_TAG_FLOAT:
-    case GI_TYPE_TAG_DOUBLE:
-    case GI_TYPE_TAG_GTYPE:
-        break;
-    case GI_TYPE_TAG_UTF8:
-    case GI_TYPE_TAG_FILENAME:
-    case GI_TYPE_TAG_ARRAY:
-        rb_raise(rb_eNotImpError,
-                 "TODO: in transfer (%s)",
-                 g_type_tag_to_string(type_tag));
-        break;
-    case GI_TYPE_TAG_INTERFACE:
-        rb_gi_in_argument_transfer_interface(argument, transfer,
-                                             type_info, rb_argument);
-        break;
-    case GI_TYPE_TAG_GLIST:
-    case GI_TYPE_TAG_GSLIST:
-    case GI_TYPE_TAG_GHASH:
-    case GI_TYPE_TAG_ERROR:
-    case GI_TYPE_TAG_UNICHAR:
-        rb_raise(rb_eNotImpError,
-                 "TODO: in transfer (%s)",
-                 g_type_tag_to_string(type_tag));
-    default:
-        g_assert_not_reached();
-        break;
-    }
-}
-GIArgument *
-rb_gi_in_argument_from_ruby(GICallableInfo *callable_info,
-                            GIArgument *argument,
-                            GIArgInfo *arg_info,
-                            guint nth_rb_argument,
-                            VALUE rb_argument,
-                            VALUE self)
-{
-    GITypeInfo type_info;
-    if (NIL_P(rb_argument)) {
-        if (rb_gi_arg_info_may_be_null(arg_info)) {
-            memset(argument, 0, sizeof(GIArgument));
-            return argument;
-        } else {
-            const char *module_name;
-            GIBaseInfo *klass;
-            const char *suffix;
-            module_name = g_base_info_get_namespace(callable_info);
-            klass = g_base_info_get_container(callable_info);
-            if (nth_rb_argument == 1) {
-                suffix = "st";
-            } else if (nth_rb_argument == 2) {
-                suffix = "nd";
-            } else if (nth_rb_argument == 3) {
-                suffix = "rd";
-            } else {
-                suffix = "th";
-            }
-            rb_raise(rb_eArgError,
-                     "<%s%s%s%s%s>: the %u%s argument must not nil: <%s>",
-                     module_name,
-                     klass ? "::" : "",
-                     klass ? g_base_info_get_name(klass) : "",
-                     klass ? "#" : ".",
-                     g_base_info_get_name(callable_info),
-                     nth_rb_argument,
-                     suffix,
-                     g_base_info_get_name(arg_info));
-        }
-    }
-    g_arg_info_load_type(arg_info, &type_info);
-    if (g_arg_info_get_direction(arg_info) == GI_DIRECTION_INOUT) {
-        rb_gi_inout_argument_from_ruby(argument, arg_info, &type_info,
-                                       rb_argument, self);
-    } else {
-        rb_gi_value_argument_from_ruby(argument, &type_info, rb_argument, self);
-        rb_gi_in_argument_transfer(argument,
-                                   g_arg_info_get_ownership_transfer(arg_info),
-                                   &type_info,
-                                   rb_argument);
-    }
-    return argument;
-}
-static void
-set_in_array_length_argument(GIArgument *argument,
-                             GITypeInfo *type_info,
-                             gint64 length)
-{
-    GITypeTag type_tag;
-    if (!argument) {
-        return;
-    }
-    type_tag = g_type_info_get_tag(type_info);
-    switch (type_tag) {
-    case GI_TYPE_TAG_VOID:
-    case GI_TYPE_TAG_BOOLEAN:
-        rb_raise(rb_eNotImpError,
-                 "TODO: invalid argument?: length[%s]",
-                 g_type_tag_to_string(type_tag));
-        break;
-    case GI_TYPE_TAG_INT8:
-        argument->v_int8 = length;
-        break;
-    case GI_TYPE_TAG_UINT8:
-        argument->v_uint8 = length;
-        break;
-    case GI_TYPE_TAG_INT16:
-        argument->v_int16 = length;
-        break;
-    case GI_TYPE_TAG_UINT16:
-        argument->v_uint16 = length;
-        break;
-    case GI_TYPE_TAG_INT32:
-        argument->v_int32 = (gint32)length;
-        break;
-    case GI_TYPE_TAG_UINT32:
-        argument->v_uint32 = (guint32)length;
-        break;
-    case GI_TYPE_TAG_INT64:
-        argument->v_int64 = length;
-        break;
-    case GI_TYPE_TAG_UINT64:
-        argument->v_uint64 = length;
-        break;
-    case GI_TYPE_TAG_FLOAT:
-    case GI_TYPE_TAG_DOUBLE:
-    case GI_TYPE_TAG_GTYPE:
-    case GI_TYPE_TAG_UTF8:
-    case GI_TYPE_TAG_FILENAME:
-    case GI_TYPE_TAG_ARRAY:
-    case GI_TYPE_TAG_INTERFACE:
-    case GI_TYPE_TAG_GLIST:
-    case GI_TYPE_TAG_GSLIST:
-    case GI_TYPE_TAG_GHASH:
-    case GI_TYPE_TAG_ERROR:
-    case GI_TYPE_TAG_UNICHAR:
         rb_raise(rb_eNotImpError,
-                 "TODO: invalid argument?: length[%s]",
-                 g_type_tag_to_string(type_tag));
-        break;
-    default:
-        g_assert_not_reached();
+                 "TODO: free GIArgument(interface)[value] everything");
+        break;
+    case GI_INFO_TYPE_SIGNAL:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[signal] everything");
+        break;
+    case GI_INFO_TYPE_VFUNC:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[vfunc] everything");
+        break;
+    case GI_INFO_TYPE_PROPERTY:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[property] everything");
+        break;
+    case GI_INFO_TYPE_FIELD:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[field] everything");
+        break;
+    case GI_INFO_TYPE_ARG:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[arg] everything");
+        break;
+    case GI_INFO_TYPE_TYPE:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[type] everything");
+        break;
+    case GI_INFO_TYPE_UNRESOLVED:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(interface)[unresolved] everything");
+        break;
+    default:
+        g_assert_not_reached();
         break;
     }
 }
 static void
-set_in_array_boolean_arguments_from_ruby(GIArgument *array_argument,
-                                         VALUE rb_boolean_array)
-{
-    gboolean *booleans;
-    long i, n_args;
-    n_args = RARRAY_LEN(rb_boolean_array);
-    booleans = ALLOC_N(gboolean, n_args);
-    for (i = 0; i < n_args; i++) {
-        booleans[i] = RVAL2CBOOL(RARRAY_PTR(rb_boolean_array)[i]);
-    }
-    array_argument->v_pointer = booleans;
-}
-static void
-set_in_array_int8_arguments_from_ruby(GIArgument *array_argument,
-                                      VALUE rb_number_array)
-{
-    gint8 *numbers;
-    long i, n_args;
-    n_args = RARRAY_LEN(rb_number_array);
-    numbers = ALLOC_N(gint8, n_args);
-    for (i = 0; i < n_args; i++) {
-        numbers[i] = NUM2CHR(RARRAY_PTR(rb_number_array)[i]);
-    }
-    array_argument->v_pointer = numbers;
-}
-static void
-set_in_array_uint8_arguments_from_ruby(GIArgument *array_argument,
-                                       VALUE rb_number_array)
-{
-    guint8 *numbers;
-    long i, n_args;
-    n_args = RARRAY_LEN(rb_number_array);
-    numbers = ALLOC_N(guint8, n_args);
-    for (i = 0; i < n_args; i++) {
-        numbers[i] = (guint8)NUM2CHR(RARRAY_PTR(rb_number_array)[i]);
-    }
-    array_argument->v_pointer = numbers;
-}
-static void
-set_in_array_int16_arguments_from_ruby(GIArgument *array_argument,
-                                       VALUE rb_number_array)
-{
-    gint16 *numbers;
-    long i, n_args;
-    n_args = RARRAY_LEN(rb_number_array);
-    numbers = ALLOC_N(gint16, n_args);
-    for (i = 0; i < n_args; i++) {
-        numbers[i] = NUM2SHORT(RARRAY_PTR(rb_number_array)[i]);
-    }
-    array_argument->v_pointer = numbers;
-}
-static void
-set_in_array_uint16_arguments_from_ruby(GIArgument *array_argument,
-                                        VALUE rb_number_array)
-{
-    guint16 *numbers;
-    long i, n_args;
-    n_args = RARRAY_LEN(rb_number_array);
-    numbers = ALLOC_N(guint16, n_args);
-    for (i = 0; i < n_args; i++) {
-        numbers[i] = NUM2USHORT(RARRAY_PTR(rb_number_array)[i]);
-    }
-    array_argument->v_pointer = numbers;
-}
-static void
-set_in_array_int32_arguments_from_ruby(GIArgument *array_argument,
-                                       VALUE rb_number_array)
-{
-    gint32 *numbers;
-    long i, n_args;
-    n_args = RARRAY_LEN(rb_number_array);
-    numbers = ALLOC_N(gint32, n_args);
-    for (i = 0; i < n_args; i++) {
-        numbers[i] = NUM2INT(RARRAY_PTR(rb_number_array)[i]);
-    }
-    array_argument->v_pointer = numbers;
-}
-static void
-set_in_array_uint32_arguments_from_ruby(GIArgument *array_argument,
-                                        VALUE rb_number_array)
-{
-    guint32 *numbers;
-    long i, n_args;
-    n_args = RARRAY_LEN(rb_number_array);
-    numbers = ALLOC_N(guint32, n_args);
-    for (i = 0; i < n_args; i++) {
-        numbers[i] = NUM2UINT(RARRAY_PTR(rb_number_array)[i]);
-    }
-    array_argument->v_pointer = numbers;
-}
-static void
-set_in_array_int64_arguments_from_ruby(GIArgument *array_argument,
-                                       VALUE rb_number_array)
-{
-    gint64 *numbers;
-    long i, n_args;
-    n_args = RARRAY_LEN(rb_number_array);
-    numbers = ALLOC_N(gint64, n_args);
-    for (i = 0; i < n_args; i++) {
-        numbers[i] = NUM2LL(RARRAY_PTR(rb_number_array)[i]);
-    }
-    array_argument->v_pointer = numbers;
-}
-static void
-set_in_array_uint64_arguments_from_ruby(GIArgument *array_argument,
-                                        VALUE rb_number_array)
-{
-    guint64 *numbers;
-    long i, n_args;
-    n_args = RARRAY_LEN(rb_number_array);
-    numbers = ALLOC_N(guint64, n_args);
-    for (i = 0; i < n_args; i++) {
-        numbers[i] = NUM2ULL(RARRAY_PTR(rb_number_array)[i]);
-    }
-    array_argument->v_pointer = numbers;
-}
-static void
-set_in_array_float_arguments_from_ruby(GIArgument *array_argument,
-                                       VALUE rb_number_array)
-{
-    gfloat *numbers;
-    long i, n_args;
-    n_args = RARRAY_LEN(rb_number_array);
-    numbers = ALLOC_N(gfloat, n_args);
-    for (i = 0; i < n_args; i++) {
-        numbers[i] = NUM2DBL(RARRAY_PTR(rb_number_array)[i]);
-    }
-    array_argument->v_pointer = numbers;
-}
-static void
-set_in_array_double_arguments_from_ruby(GIArgument *array_argument,
-                                        VALUE rb_number_array)
-{
-    gdouble *numbers;
-    long i, n_args;
-    n_args = RARRAY_LEN(rb_number_array);
-    numbers = ALLOC_N(gdouble, n_args);
-    for (i = 0; i < n_args; i++) {
-        numbers[i] = NUM2DBL(RARRAY_PTR(rb_number_array)[i]);
-    }
-    array_argument->v_pointer = numbers;
-}
-static void
-set_in_array_gtype_arguments_from_ruby(GIArgument *array_argument,
-                                       VALUE rb_types)
-{
-    GType *types;
-    long i, n_types;
-    n_types = RARRAY_LEN(rb_types);
-    types = ALLOC_N(GType, n_types);
-    for (i = 0; i < n_types; i++) {
-        VALUE rb_type = RARRAY_PTR(rb_types)[i];
-        types[i] = rbgobj_gtype_get(rb_type);
-    }
-    array_argument->v_pointer = types;
-}
-typedef struct {
-    GIStructInfo *struct_info;
-    VALUE rb_argument;
-    long n_args;
-    gchar *values;
-} ArrayInterfaceStructFromRubyData;
-static VALUE
-set_in_array_interface_struct_arguments_from_ruby_body(VALUE value)
-{
-    ArrayInterfaceStructFromRubyData *data;
-    gsize size;
-    gint i;
-    data = (ArrayInterfaceStructFromRubyData *)value;
-    size = g_struct_info_get_size(data->struct_info);
-    data->values = xmalloc(size * data->n_args);
-    for (i = 0; i < data->n_args; i++) {
-        VALUE rb_element;
-        gpointer element;
-        rb_element = RARRAY_PTR(data->rb_argument)[i];
-        element = rb_gi_struct_info_from_ruby(data->struct_info, rb_element);
-        memcpy(data->values + (size * i),
-               element,
-               size);
-    }
-    return Qnil;
-}
-static G_GNUC_NORETURN VALUE
-set_in_array_interface_struct_arguments_from_ruby_rescue(VALUE value)
-{
-    ArrayInterfaceStructFromRubyData *data;
-    data = (ArrayInterfaceStructFromRubyData *)value;
-    g_base_info_unref((GIBaseInfo *)(data->struct_info));
-    xfree(data->values);
-    rb_exc_raise(rb_errinfo());
-}
-static void
-set_in_array_interface_struct_arguments_from_ruby(GIArgument *array_argument,
-                                                  GIStructInfo *struct_info,
-                                                  VALUE rb_argument)
-{
-    ArrayInterfaceStructFromRubyData data;
-    data.struct_info = struct_info;
-    data.rb_argument = rb_argument;
-    data.n_args = RARRAY_LEN(rb_argument);
-    data.values = NULL;
-    rb_rescue(set_in_array_interface_struct_arguments_from_ruby_body,
-              (VALUE)&data,
-              set_in_array_interface_struct_arguments_from_ruby_rescue,
-              (VALUE)&data);
-    array_argument->v_pointer = data.values;
-}
-typedef struct {
-    VALUE rb_argument;
-    long n_args;
-    gpointer *values;
-} ArrayInterfaceObjectFromRubyData;
-static VALUE
-set_in_array_interface_object_arguments_from_ruby_body(VALUE value)
-{
-    ArrayInterfaceObjectFromRubyData *data;
-    gint i;
-    data = (ArrayInterfaceObjectFromRubyData *)value;
-    data->values = xmalloc(sizeof(gpointer) * data->n_args);
-    for (i = 0; i < data->n_args; i++) {
-        VALUE rb_element;
-        rb_element = RARRAY_AREF(data->rb_argument, i);
-        data->values[i] = RVAL2GOBJ(rb_element);
-    }
-    return Qnil;
-}
-static G_GNUC_NORETURN VALUE
-set_in_array_interface_object_arguments_from_ruby_rescue(VALUE value)
+rb_gi_boxed_free_callback(gpointer boxed, gpointer user_data)
 {
-    ArrayInterfaceObjectFromRubyData *data;
-    data = (ArrayInterfaceObjectFromRubyData *)value;
-    xfree(data->values);
+    GType *gtype = user_data;
-    rb_exc_raise(rb_errinfo());
+    g_boxed_free(*gtype, boxed);
 }
-static void
-set_in_array_interface_object_arguments_from_ruby(GIArgument *array_argument,
-                                                  VALUE rb_argument)
-{
-    ArrayInterfaceObjectFromRubyData data;
-    data.rb_argument = rb_argument;
-    data.n_args = RARRAY_LEN(rb_argument);
-    data.values = NULL;
-    rb_rescue(set_in_array_interface_object_arguments_from_ruby_body,
-              (VALUE)&data,
-              set_in_array_interface_object_arguments_from_ruby_rescue,
-              (VALUE)&data);
-    array_argument->v_pointer = data.values;
-}
 static void
-set_in_array_interface_arguments_from_ruby(GIArgument *array_argument,
-                                           GITypeInfo *element_type_info,
-                                           VALUE rb_argument)
+rb_gi_return_argument_free_everything_glist_interface(GIArgument *argument,
+                                                      G_GNUC_UNUSED GITypeInfo *type_info,
+                                                      GITypeInfo *element_type_info)
 {
     GIBaseInfo *interface_info;
     GIInfoType interface_type;
+    const gchar *interface_name;
     GType gtype;
-    const char *interface_name;
     interface_info = g_type_info_get_interface(element_type_info);
     interface_type = g_base_info_get_type(interface_info);
+    interface_name = g_info_type_to_string(interface_type);
     gtype = g_registered_type_info_get_g_type(interface_info);
+    g_base_info_unref(interface_info);
+    g_base_info_unref(element_type_info);
     switch (interface_type) {
     case GI_INFO_TYPE_INVALID:
     case GI_INFO_TYPE_FUNCTION:
     case GI_INFO_TYPE_CALLBACK:
-        interface_name = g_info_type_to_string(interface_type);
-        g_base_info_unref(interface_info);
         rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(array)[interface(%s)](%s)",
+                 "TODO: free GIArgument(GList)[interface(%s)](%s) everything",
                  interface_name,
                  g_type_name(gtype));
         break;
     case GI_INFO_TYPE_STRUCT:
-        {
-            GIStructInfo *struct_info = (GIStructInfo *)interface_info;
-            set_in_array_interface_struct_arguments_from_ruby(array_argument,
-                                                              struct_info,
-                                                              rb_argument);
+        if (gtype == G_TYPE_NONE) {
+            rb_raise(rb_eNotImpError,
+                     "TODO: free GIArgument(GList)[interface(%s)](%s) everything",
+                     interface_name,
+                     g_type_name(gtype));
+        } else {
+            g_list_foreach(argument->v_pointer,
+                           rb_gi_boxed_free_callback,
+                           &gtype);
+            g_list_free(argument->v_pointer);
         }
         break;
     case GI_INFO_TYPE_BOXED:
+        g_list_foreach(argument->v_pointer, rb_gi_boxed_free_callback, &gtype);
+        g_list_free(argument->v_pointer);
+        break;
     case GI_INFO_TYPE_ENUM:
     case GI_INFO_TYPE_FLAGS:
-        interface_name = g_info_type_to_string(interface_type);
-        g_base_info_unref(interface_info);
         rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(array)[interface(%s)](%s)",
+                 "TODO: free GIArgument(GList)[interface(%s)](%s) everything",
                  interface_name,
                  g_type_name(gtype));
         break;
     case GI_INFO_TYPE_OBJECT:
-        set_in_array_interface_object_arguments_from_ruby(array_argument,
-                                                          rb_argument);
-        break;
     case GI_INFO_TYPE_INTERFACE:
+        g_list_foreach(argument->v_pointer, (GFunc)g_object_unref, NULL);
+        g_list_free(argument->v_pointer);
+        break;
     case GI_INFO_TYPE_CONSTANT:
     case GI_INFO_TYPE_INVALID_0:
     case GI_INFO_TYPE_UNION:
@@ -4339,10 +1723,8 @@ set_in_array_interface_arguments_from_ruby(GIArgument *array_argument,
     case GI_INFO_TYPE_ARG:
     case GI_INFO_TYPE_TYPE:
     case GI_INFO_TYPE_UNRESOLVED:
-        interface_name = g_info_type_to_string(interface_type);
-        g_base_info_unref(interface_info);
         rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(array)[interface(%s)](%s)",
+                 "TODO: free GIArgument(GList)[interface(%s)](%s) everything",
                  interface_name,
                  g_type_name(gtype));
         break;
@@ -4353,347 +1735,20 @@ set_in_array_interface_arguments_from_ruby(GIArgument *array_argument,
 }
 static void
-in_array_c_argument_from_ruby(GIArgument *array_argument,
-                              GIArgument *length_argument,
-                              G_GNUC_UNUSED GITypeInfo *array_type_info,
-                              GITypeInfo *length_type_info,
-                              GITypeInfo *element_type_info,
-                              VALUE rb_argument)
-{
-    GITypeTag element_type_tag;
-    element_type_tag = g_type_info_get_tag(element_type_info);
-    switch (element_type_tag) {
-    case GI_TYPE_TAG_VOID:
-        rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(array)[%s]",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-    case GI_TYPE_TAG_BOOLEAN:
-        rb_argument = rbg_to_array(rb_argument);
-        set_in_array_boolean_arguments_from_ruby(array_argument, rb_argument);
-        set_in_array_length_argument(length_argument, length_type_info,
-                                     RARRAY_LEN(rb_argument));
-        break;
-    case GI_TYPE_TAG_INT8:
-        if (RB_TYPE_P(rb_argument, RUBY_T_STRING)) {
-            array_argument->v_pointer = RSTRING_PTR(rb_argument);
-            set_in_array_length_argument(length_argument, length_type_info,
-                                         RSTRING_LEN(rb_argument));
-        } else {
-            rb_argument = rbg_to_array(rb_argument);
-            set_in_array_int8_arguments_from_ruby(array_argument, rb_argument);
-            set_in_array_length_argument(length_argument, length_type_info,
-                                         RARRAY_LEN(rb_argument));
-        }
-        break;
-    case GI_TYPE_TAG_UINT8:
-        if (RB_TYPE_P(rb_argument, RUBY_T_STRING)) {
-            array_argument->v_pointer = RSTRING_PTR(rb_argument);
-            set_in_array_length_argument(length_argument, length_type_info,
-                                         RSTRING_LEN(rb_argument));
-        } else {
-            rb_argument = rbg_to_array(rb_argument);
-            set_in_array_uint8_arguments_from_ruby(array_argument, rb_argument);
-            set_in_array_length_argument(length_argument, length_type_info,
-                                         RARRAY_LEN(rb_argument));
-        }
-        break;
-    case GI_TYPE_TAG_INT16:
-        rb_argument = rbg_to_array(rb_argument);
-        set_in_array_int16_arguments_from_ruby(array_argument, rb_argument);
-        set_in_array_length_argument(length_argument, length_type_info,
-                                     RARRAY_LEN(rb_argument));
-        break;
-    case GI_TYPE_TAG_UINT16:
-        rb_argument = rbg_to_array(rb_argument);
-        set_in_array_uint16_arguments_from_ruby(array_argument, rb_argument);
-        set_in_array_length_argument(length_argument, length_type_info,
-                                     RARRAY_LEN(rb_argument));
-        break;
-    case GI_TYPE_TAG_INT32:
-        rb_argument = rbg_to_array(rb_argument);
-        set_in_array_int32_arguments_from_ruby(array_argument, rb_argument);
-        set_in_array_length_argument(length_argument, length_type_info,
-                                     RARRAY_LEN(rb_argument));
-        break;
-    case GI_TYPE_TAG_UINT32:
-        rb_argument = rbg_to_array(rb_argument);
-        set_in_array_uint32_arguments_from_ruby(array_argument, rb_argument);
-        set_in_array_length_argument(length_argument, length_type_info,
-                                     RARRAY_LEN(rb_argument));
-        break;
-    case GI_TYPE_TAG_INT64:
-        rb_argument = rbg_to_array(rb_argument);
-        set_in_array_int64_arguments_from_ruby(array_argument, rb_argument);
-        set_in_array_length_argument(length_argument, length_type_info,
-                                     RARRAY_LEN(rb_argument));
-        break;
-    case GI_TYPE_TAG_UINT64:
-        rb_argument = rbg_to_array(rb_argument);
-        set_in_array_uint64_arguments_from_ruby(array_argument, rb_argument);
-        set_in_array_length_argument(length_argument, length_type_info,
-                                     RARRAY_LEN(rb_argument));
-        break;
-    case GI_TYPE_TAG_FLOAT:
-        rb_argument = rbg_to_array(rb_argument);
-        set_in_array_float_arguments_from_ruby(array_argument, rb_argument);
-        set_in_array_length_argument(length_argument, length_type_info,
-                                     RARRAY_LEN(rb_argument));
-        break;
-    case GI_TYPE_TAG_DOUBLE:
-        rb_argument = rbg_to_array(rb_argument);
-        set_in_array_double_arguments_from_ruby(array_argument, rb_argument);
-        set_in_array_length_argument(length_argument, length_type_info,
-                                     RARRAY_LEN(rb_argument));
-        break;
-    case GI_TYPE_TAG_GTYPE:
-        rb_argument = rbg_to_array(rb_argument);
-        set_in_array_gtype_arguments_from_ruby(array_argument,
-                                               rb_argument);
-        set_in_array_length_argument(length_argument, length_type_info,
-                                     RARRAY_LEN(rb_argument));
-        break;
-    case GI_TYPE_TAG_UTF8:
-    case GI_TYPE_TAG_FILENAME:
-        rb_argument = rbg_to_array(rb_argument);
-        array_argument->v_pointer = RVAL2STRV(rb_argument);
-        set_in_array_length_argument(length_argument, length_type_info,
-                                     RARRAY_LEN(rb_argument));
-        break;
-    case GI_TYPE_TAG_ARRAY:
-        rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(array)[%s]",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-    case GI_TYPE_TAG_INTERFACE:
-        rb_argument = rbg_to_array(rb_argument);
-        set_in_array_interface_arguments_from_ruby(array_argument,
-                                                   element_type_info,
-                                                   rb_argument);
-        set_in_array_length_argument(length_argument, length_type_info,
-                                     RARRAY_LEN(rb_argument));
-        break;
-    case GI_TYPE_TAG_GLIST:
-    case GI_TYPE_TAG_GSLIST:
-    case GI_TYPE_TAG_GHASH:
-    case GI_TYPE_TAG_ERROR:
-    case GI_TYPE_TAG_UNICHAR:
-        rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(array)[%s]",
-                 g_type_tag_to_string(element_type_tag));
-        break;
-    default:
-        g_assert_not_reached();
-        break;
-    }
-}
-static void
-in_array_argument_from_ruby(GIArgument *array_argument,
-                            GIArgument *length_argument,
-                            GITypeInfo *array_type_info,
-                            GITypeInfo *length_type_info,
-                            VALUE rb_argument)
-{
-    GIArrayType array_type;
-    GITypeInfo *element_type_info;
-    array_type = g_type_info_get_array_type(array_type_info);
-    element_type_info = g_type_info_get_param_type(array_type_info, 0);
-    switch (array_type) {
-    case GI_ARRAY_TYPE_C:
-        in_array_c_argument_from_ruby(array_argument,
-                                      length_argument,
-                                      array_type_info,
-                                      length_type_info,
-                                      element_type_info,
-                                      rb_argument);
-        break;
-    case GI_ARRAY_TYPE_ARRAY:
-    case GI_ARRAY_TYPE_PTR_ARRAY:
-    case GI_ARRAY_TYPE_BYTE_ARRAY:
-        rb_raise(rb_eNotImpError,
-                 "TODO: Ruby -> GIArgument(array)[%s]",
-                 g_type_tag_to_string(g_type_info_get_tag(element_type_info)));
-        break;
-    default:
-        g_assert_not_reached();
-        break;
-    }
-    g_base_info_unref(element_type_info);
-}
-static void
-set_inout_array_length_argument(GIArgument *argument,
-                                GITypeInfo *type_info,
-                                GIArgument *length)
-{
-    GITypeTag type_tag;
-    if (!argument) {
-        return;
-    }
-    type_tag = g_type_info_get_tag(type_info);
-    switch (type_tag) {
-    case GI_TYPE_TAG_VOID:
-    case GI_TYPE_TAG_BOOLEAN:
-        rb_raise(rb_eNotImpError,
-                 "TODO: invalid argument?: length[%s]",
-                 g_type_tag_to_string(type_tag));
-        break;
-    case GI_TYPE_TAG_INT8:
-        argument->v_pointer = ALLOC(gint8);
-        *((gint8 *)argument->v_pointer) = length->v_int8;
-        break;
-    case GI_TYPE_TAG_UINT8:
-        argument->v_pointer = ALLOC(guint8);
-        *((guint8 *)argument->v_pointer) = length->v_uint8;
-        break;
-    case GI_TYPE_TAG_INT16:
-        argument->v_pointer = ALLOC(gint16);
-        *((gint16 *)argument->v_pointer) = length->v_int16;
-        break;
-    case GI_TYPE_TAG_UINT16:
-        argument->v_pointer = ALLOC(guint16);
-        *((guint16 *)argument->v_pointer) = length->v_uint16;
-        break;
-    case GI_TYPE_TAG_INT32:
-        argument->v_pointer = ALLOC(gint32);
-        *((gint32 *)argument->v_pointer) = length->v_int32;
-        break;
-    case GI_TYPE_TAG_UINT32:
-        argument->v_pointer = ALLOC(guint32);
-        *((guint32 *)argument->v_pointer) = length->v_uint32;
-        break;
-    case GI_TYPE_TAG_INT64:
-        argument->v_pointer = ALLOC(gint64);
-        *((gint64 *)argument->v_pointer) = length->v_int64;
-        break;
-    case GI_TYPE_TAG_UINT64:
-        argument->v_pointer = ALLOC(guint64);
-        *((guint64 *)argument->v_pointer) = length->v_uint64;
-        break;
-    case GI_TYPE_TAG_FLOAT:
-    case GI_TYPE_TAG_DOUBLE:
-    case GI_TYPE_TAG_GTYPE:
-    case GI_TYPE_TAG_UTF8:
-    case GI_TYPE_TAG_FILENAME:
-    case GI_TYPE_TAG_ARRAY:
-    case GI_TYPE_TAG_INTERFACE:
-    case GI_TYPE_TAG_GLIST:
-    case GI_TYPE_TAG_GSLIST:
-    case GI_TYPE_TAG_GHASH:
-    case GI_TYPE_TAG_ERROR:
-    case GI_TYPE_TAG_UNICHAR:
-        rb_raise(rb_eNotImpError,
-                 "TODO: invalid argument?: length[%s]",
-                 g_type_tag_to_string(type_tag));
-        break;
-    default:
-        g_assert_not_reached();
-        break;
-    }
-}
-static void
-inout_array_argument_from_ruby(GIArgument *array_argument,
-                               GIArgument *length_argument,
-                               GITypeInfo *array_type_info,
-                               GITypeInfo *length_type_info,
-                               VALUE rb_argument)
-{
-    GIArgument in_array_argument;
-    GIArgument in_length_argument;
-    in_array_argument_from_ruby(&in_array_argument,
-                                &in_length_argument,
-                                array_type_info,
-                                length_type_info,
-                                rb_argument);
-    array_argument->v_pointer = ALLOC(gpointer);
-    *((gpointer *)array_argument->v_pointer) = in_array_argument.v_pointer;
-    set_inout_array_length_argument(length_argument,
-                                    length_type_info,
-                                    &in_length_argument);
-}
-GIArgument *
-rb_gi_in_array_argument_from_ruby(GIArgument *array_argument,
-                                  GIArgument *length_argument,
-                                  GIArgInfo *array_arg_info,
-                                  GIArgInfo *length_arg_info,
-                                  VALUE rb_argument)
-{
-    GITypeInfo array_type_info;
-    GITypeInfo length_type_info;
-    GITypeInfo *length_type_info_arg = NULL;
-    if (NIL_P(rb_argument) && rb_gi_arg_info_may_be_null(array_arg_info)) {
-        memset(array_argument, 0, sizeof(GIArgument));
-        if (length_argument) {
-            memset(length_argument, 0, sizeof(GIArgument));
-        }
-        return array_argument;
-    }
-    g_arg_info_load_type(array_arg_info, &array_type_info);
-    if (length_arg_info) {
-        g_arg_info_load_type(length_arg_info, &length_type_info);
-        length_type_info_arg = &length_type_info;
-    }
-    if (g_arg_info_get_direction(array_arg_info) == GI_DIRECTION_INOUT) {
-        inout_array_argument_from_ruby(array_argument,
-                                       length_argument,
-                                       &array_type_info,
-                                       length_type_info_arg,
-                                       rb_argument);
-    } else {
-        GITransfer transfer;
-        in_array_argument_from_ruby(array_argument,
-                                    length_argument,
-                                    &array_type_info,
-                                    length_type_info_arg,
-                                    rb_argument);
-        transfer = g_arg_info_get_ownership_transfer(array_arg_info);
-        rb_gi_in_argument_transfer(array_argument,
-                                   transfer,
-                                   &array_type_info,
-                                   rb_argument);
-    }
-    return array_argument;
-}
-static void
-rb_gi_value_argument_free_array_c(VALUE rb_argument,
-                                  GIArgument *argument,
-                                  G_GNUC_UNUSED GITypeInfo *type_info,
-                                  GITypeInfo *element_type_info)
+rb_gi_return_argument_free_everything_glist(GIArgument *argument,
+                                            GITypeInfo *type_info)
 {
+    GITypeInfo *element_type_info;
     GITypeTag element_type_tag;
+    element_type_info = g_type_info_get_param_type(type_info, 0);
     element_type_tag = g_type_info_get_tag(element_type_info);
     switch (element_type_tag) {
     case GI_TYPE_TAG_VOID:
-        rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(array)[%s]",
-                 g_type_tag_to_string(element_type_tag));
-        break;
     case GI_TYPE_TAG_BOOLEAN:
-        xfree(argument->v_pointer);
-        break;
     case GI_TYPE_TAG_INT8:
     case GI_TYPE_TAG_UINT8:
-        if (RB_TYPE_P(rb_argument, RUBY_T_STRING)) {
-            /* Do nothing */
-        } else {
-            xfree(argument->v_pointer);
-        }
-        break;
     case GI_TYPE_TAG_INT16:
     case GI_TYPE_TAG_UINT16:
     case GI_TYPE_TAG_INT32:
@@ -4703,101 +1758,136 @@ rb_gi_value_argument_free_array_c(VALUE rb_argument,
     case GI_TYPE_TAG_FLOAT:
     case GI_TYPE_TAG_DOUBLE:
     case GI_TYPE_TAG_GTYPE:
-        xfree(argument->v_pointer);
+        g_base_info_unref(element_type_info);
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(GList)[%s] everything",
+                 g_type_tag_to_string(element_type_tag));
         break;
     case GI_TYPE_TAG_UTF8:
-    case GI_TYPE_TAG_FILENAME:
-        g_free(argument->v_pointer);
+        g_base_info_unref(element_type_info);
+        g_list_foreach(argument->v_pointer, (GFunc)g_free, NULL);
+        g_list_free(argument->v_pointer);
         break;
+    case GI_TYPE_TAG_FILENAME:
     case GI_TYPE_TAG_ARRAY:
+        g_base_info_unref(element_type_info);
         rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(array)[%s]",
+                 "TODO: free GIArgument(GList)[%s] everything",
                  g_type_tag_to_string(element_type_tag));
         break;
     case GI_TYPE_TAG_INTERFACE:
-        xfree(argument->v_pointer);
+        rb_gi_return_argument_free_everything_glist_interface(argument,
+                                                              type_info,
+                                                              element_type_info);
         break;
     case GI_TYPE_TAG_GLIST:
     case GI_TYPE_TAG_GSLIST:
     case GI_TYPE_TAG_GHASH:
     case GI_TYPE_TAG_ERROR:
     case GI_TYPE_TAG_UNICHAR:
+        g_base_info_unref(element_type_info);
         rb_raise(rb_eNotImpError,
-                 "TODO: free GIArgument(array)[%s]",
+                 "TODO: free GIArgument(GList)[%s] everything",
                  g_type_tag_to_string(element_type_tag));
         break;
     default:
+        g_base_info_unref(element_type_info);
         g_assert_not_reached();
         break;
     }
 }
 static void
-rb_gi_value_argument_free_array(VALUE rb_argument,
-                                GIArgument *argument,
-                                GITypeInfo *type_info)
+rb_gi_return_argument_free_everything_gslist_interface(GIArgument *argument,
+                                                       G_GNUC_UNUSED GITypeInfo *type_info,
+                                                       GITypeInfo *element_type_info)
 {
-    GIArrayType array_type;
-    GITypeInfo *element_type_info;
+    GIBaseInfo *interface_info;
+    GIInfoType interface_type;
+    const gchar *interface_name;
+    GType gtype;
-    array_type = g_type_info_get_array_type(type_info);
-    element_type_info = g_type_info_get_param_type(type_info, 0);
-    switch (array_type) {
-    case GI_ARRAY_TYPE_C:
-        rb_gi_value_argument_free_array_c(rb_argument,
-                                          argument,
-                                          type_info,
-                                          element_type_info);
+    interface_info = g_type_info_get_interface(element_type_info);
+    interface_type = g_base_info_get_type(interface_info);
+    interface_name = g_info_type_to_string(interface_type);
+    gtype = g_registered_type_info_get_g_type(interface_info);
+    g_base_info_unref(interface_info);
+    g_base_info_unref(element_type_info);
+    switch (interface_type) {
+      case GI_INFO_TYPE_INVALID:
+      case GI_INFO_TYPE_FUNCTION:
+      case GI_INFO_TYPE_CALLBACK:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(GSList)[interface(%s)](%s) everything",
+                 interface_name,
+                 g_type_name(gtype));
         break;
-    case GI_ARRAY_TYPE_ARRAY:
-    case GI_ARRAY_TYPE_PTR_ARRAY:
-    case GI_ARRAY_TYPE_BYTE_ARRAY:
+      case GI_INFO_TYPE_STRUCT:
+        if (gtype == G_TYPE_NONE) {
+            rb_raise(rb_eNotImpError,
+                     "TODO: free GIArgument(GSList)[interface(%s)](%s) everything",
+                     interface_name,
+                     g_type_name(gtype));
+        } else {
+            g_slist_foreach(argument->v_pointer,
+                            rb_gi_boxed_free_callback,
+                            &gtype);
+            g_slist_free(argument->v_pointer);
+        }
         break;
-    default:
+      case GI_INFO_TYPE_BOXED:
+        g_slist_foreach(argument->v_pointer, rb_gi_boxed_free_callback, &gtype);
+        g_slist_free(argument->v_pointer);
+        break;
+      case GI_INFO_TYPE_ENUM:
+      case GI_INFO_TYPE_FLAGS:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(GSList)[interface(%s)](%s) everything",
+                 interface_name,
+                 g_type_name(gtype));
+        break;
+      case GI_INFO_TYPE_OBJECT:
+      case GI_INFO_TYPE_INTERFACE:
+        g_slist_foreach(argument->v_pointer, (GFunc)g_object_unref, NULL);
+        g_slist_free(argument->v_pointer);
+        break;
+      case GI_INFO_TYPE_CONSTANT:
+      case GI_INFO_TYPE_INVALID_0:
+      case GI_INFO_TYPE_UNION:
+      case GI_INFO_TYPE_VALUE:
+      case GI_INFO_TYPE_SIGNAL:
+      case GI_INFO_TYPE_VFUNC:
+      case GI_INFO_TYPE_PROPERTY:
+      case GI_INFO_TYPE_FIELD:
+      case GI_INFO_TYPE_ARG:
+      case GI_INFO_TYPE_TYPE:
+      case GI_INFO_TYPE_UNRESOLVED:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(GSList)[interface(%s)](%s) everything",
+                 interface_name,
+                 g_type_name(gtype));
+        break;
+      default:
         g_assert_not_reached();
         break;
     }
-    g_base_info_unref(element_type_info);
 }
 static void
-rb_gi_value_argument_free_interface(VALUE rb_argument,
-                                    GIArgument *argument,
-                                    GITypeInfo *type_info)
+rb_gi_return_argument_free_everything_gslist(GIArgument *argument,
+                                             GITypeInfo *type_info)
 {
-    GIBaseInfo *interface_info;
-    GIInfoType interface_type;
-    interface_info = g_type_info_get_interface(type_info);
-    interface_type = g_base_info_get_type(interface_info);
-    if (interface_type == GI_INFO_TYPE_STRUCT) {
-        GType gtype;
-        gtype = g_registered_type_info_get_g_type(interface_info);
-        if (gtype == G_TYPE_VALUE) {
-            if (!RVAL2CBOOL(rb_obj_is_kind_of(rb_argument, rb_cGLibValue))) {
-                GValue *gvalue = argument->v_pointer;
-                g_value_unset(gvalue);
-                xfree(argument->v_pointer);
-            }
-        } else if (gtype == G_TYPE_BYTES) {
-            g_bytes_unref(argument->v_pointer);
-        }
-    }
+    GITypeInfo *element_type_info;
+    GITypeTag element_type_tag;
-    g_base_info_unref(interface_info);
-}
+    if (!argument->v_pointer)
+        return;
-void
-rb_gi_value_argument_free(VALUE rb_argument,
-                          GIArgument *argument,
-                          GITypeInfo *type_info)
-{
-    GITypeTag type_tag;
+    element_type_info = g_type_info_get_param_type(type_info, 0);
+    element_type_tag = g_type_info_get_tag(element_type_info);
-    type_tag = g_type_info_get_tag(type_info);
-    switch (type_tag) {
+    switch (element_type_tag) {
     case GI_TYPE_TAG_VOID:
     case GI_TYPE_TAG_BOOLEAN:
     case GI_TYPE_TAG_INT8:
@@ -4811,134 +1901,137 @@ rb_gi_value_argument_free(VALUE rb_argument,
     case GI_TYPE_TAG_FLOAT:
     case GI_TYPE_TAG_DOUBLE:
     case GI_TYPE_TAG_GTYPE:
+        g_base_info_unref(element_type_info);
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(GSList)[%s] everything",
+                 g_type_tag_to_string(element_type_tag));
+        break;
     case GI_TYPE_TAG_UTF8:
     case GI_TYPE_TAG_FILENAME:
+        g_base_info_unref(element_type_info);
+        g_slist_foreach(argument->v_pointer, (GFunc)g_free, NULL);
+        g_slist_free(argument->v_pointer);
         break;
     case GI_TYPE_TAG_ARRAY:
-        rb_gi_value_argument_free_array(rb_argument, argument, type_info);
+        g_base_info_unref(element_type_info);
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(GSList)[%s] everything",
+                 g_type_tag_to_string(element_type_tag));
         break;
     case GI_TYPE_TAG_INTERFACE:
-        rb_gi_value_argument_free_interface(rb_argument, argument, type_info);
+        rb_gi_return_argument_free_everything_gslist_interface(argument,
+                                                               type_info,
+                                                               element_type_info);
         break;
     case GI_TYPE_TAG_GLIST:
     case GI_TYPE_TAG_GSLIST:
     case GI_TYPE_TAG_GHASH:
     case GI_TYPE_TAG_ERROR:
     case GI_TYPE_TAG_UNICHAR:
+        g_base_info_unref(element_type_info);
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(GSList)[%s] everything",
+                 g_type_tag_to_string(element_type_tag));
         break;
     default:
+        g_base_info_unref(element_type_info);
         g_assert_not_reached();
         break;
     }
 }
 static void
-rb_gi_inout_argument_free(VALUE rb_argument,
-                          GIArgument *argument,
-                          GITypeInfo *type_info)
+rb_gi_return_argument_free_everything(GIArgument *argument,
+                                      GITypeInfo *type_info)
 {
-    GIArgument in_argument;
     GITypeTag type_tag;
-    memset(&in_argument, 0, sizeof(GIArgument));
     type_tag = g_type_info_get_tag(type_info);
     switch (type_tag) {
-    case GI_TYPE_TAG_VOID:
-        break;
-    case GI_TYPE_TAG_BOOLEAN:
-        in_argument.v_boolean = *((gboolean *)(argument->v_pointer));
-        break;
-    case GI_TYPE_TAG_INT8:
-        in_argument.v_int8 = *((gint8 *)(argument->v_pointer));
-        break;
-    case GI_TYPE_TAG_UINT8:
-        /* TODO!!! */
-        in_argument.v_uint8 = *((guint8 *)(argument->v_pointer));
-        argument->v_pointer = ALLOC(guint8);
-        *((guint8 *)argument->v_pointer) = in_argument.v_uint8;
-        break;
-    case GI_TYPE_TAG_INT16:
-        in_argument.v_int16 = *((gint16 *)(argument->v_pointer));
-        argument->v_pointer = ALLOC(gint16);
-        *((gint16 *)argument->v_pointer) = in_argument.v_int16;
-        break;
-    case GI_TYPE_TAG_UINT16:
-        in_argument.v_uint16 = *((guint16 *)(argument->v_pointer));
-        argument->v_pointer = ALLOC(guint16);
-        *((guint16 *)argument->v_pointer) = in_argument.v_uint16;
-        break;
-    case GI_TYPE_TAG_INT32:
-        in_argument.v_int32 = *((gint32 *)(argument->v_pointer));
-        argument->v_pointer = ALLOC(gint32);
-        *((gint32 *)argument->v_pointer) = in_argument.v_int32;
-        break;
-    case GI_TYPE_TAG_UINT32:
-        in_argument.v_uint32 = *((guint32 *)(argument->v_pointer));
-        argument->v_pointer = ALLOC(guint32);
-        *((guint32 *)argument->v_pointer) = in_argument.v_uint32;
+      case GI_TYPE_TAG_VOID:
         break;
-    case GI_TYPE_TAG_INT64:
-        in_argument.v_int64 = *((gint64 *)(argument->v_pointer));
-        argument->v_pointer = ALLOC(gint64);
-        *((gint64 *)argument->v_pointer) = in_argument.v_int64;
+      case GI_TYPE_TAG_BOOLEAN:
+      case GI_TYPE_TAG_INT8:
+      case GI_TYPE_TAG_UINT8:
+      case GI_TYPE_TAG_INT16:
+      case GI_TYPE_TAG_UINT16:
+      case GI_TYPE_TAG_INT32:
+      case GI_TYPE_TAG_UINT32:
+      case GI_TYPE_TAG_INT64:
+      case GI_TYPE_TAG_UINT64:
+      case GI_TYPE_TAG_FLOAT:
+      case GI_TYPE_TAG_DOUBLE:
+      case GI_TYPE_TAG_GTYPE:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(%s) everything",
+                 g_type_tag_to_string(type_tag));
         break;
-    case GI_TYPE_TAG_UINT64:
-        in_argument.v_uint64 = *((guint64 *)(argument->v_pointer));
-        argument->v_pointer = ALLOC(guint64);
-        *((guint64 *)argument->v_pointer) = in_argument.v_uint64;
+      case GI_TYPE_TAG_UTF8:
+        g_free(argument->v_string);
         break;
-    case GI_TYPE_TAG_FLOAT:
-        in_argument.v_float = *((gfloat *)(argument->v_pointer));
-        argument->v_pointer = ALLOC(gfloat);
-        *((gfloat *)argument->v_pointer) = in_argument.v_float;
+      case GI_TYPE_TAG_FILENAME:
+        g_free(argument->v_string);
         break;
-    case GI_TYPE_TAG_DOUBLE:
-        in_argument.v_double = *((gdouble *)(argument->v_pointer));
-        argument->v_pointer = ALLOC(gdouble);
-        *((gdouble *)argument->v_pointer) = in_argument.v_double;
+      case GI_TYPE_TAG_ARRAY:
+        rb_gi_return_argument_free_everything_array(argument, type_info);
         break;
-    case GI_TYPE_TAG_GTYPE:
-        in_argument.v_size = *((gsize *)(argument->v_pointer));
+      case GI_TYPE_TAG_INTERFACE:
+        rb_gi_return_argument_free_everything_interface(argument, type_info);
         break;
-    case GI_TYPE_TAG_UTF8:
-    case GI_TYPE_TAG_FILENAME:
-        in_argument.v_string = *((gchar **)(argument->v_pointer));
+      case GI_TYPE_TAG_GLIST:
+        rb_gi_return_argument_free_everything_glist(argument, type_info);
         break;
-    case GI_TYPE_TAG_ARRAY:
-    case GI_TYPE_TAG_INTERFACE:
-    case GI_TYPE_TAG_GLIST:
-    case GI_TYPE_TAG_GSLIST:
-    case GI_TYPE_TAG_GHASH:
-        in_argument.v_pointer = *((gpointer *)(argument->v_pointer));
+      case GI_TYPE_TAG_GSLIST:
+        rb_gi_return_argument_free_everything_gslist(argument, type_info);
         break;
-    case GI_TYPE_TAG_ERROR:
-        in_argument.v_pointer = *((GError **)(argument->v_pointer));
+      case GI_TYPE_TAG_GHASH:
+        g_hash_table_unref(argument->v_pointer);
         break;
-    case GI_TYPE_TAG_UNICHAR:
-        in_argument.v_uint32 = *((gunichar *)(argument->v_pointer));
+      case GI_TYPE_TAG_ERROR:
+      case GI_TYPE_TAG_UNICHAR:
+        rb_raise(rb_eNotImpError,
+                 "TODO: free GIArgument(%s) everything",
+                 g_type_tag_to_string(type_tag));
         break;
-    default:
+      default:
         g_assert_not_reached();
         break;
     }
-    rb_gi_value_argument_free(rb_argument, &in_argument, type_info);
-    xfree(argument->v_pointer);
 }
-void
-rb_gi_in_argument_free(VALUE rb_argument,
-                       GIArgument *argument,
-                       GIArgInfo *arg_info)
+VALUE
+rb_gi_return_argument_to_ruby(GICallableInfo *callable_info,
+                              GIArgument *argument,
+                              GArray *in_args,
+                              GArray *out_args,
+                              GPtrArray *args_metadata)
 {
-    GITypeInfo type_info;
+    VALUE rb_argument;
+    gboolean may_return_null;
+    GITypeInfo return_value_info;
-    g_arg_info_load_type(arg_info, &type_info);
-    if (g_arg_info_get_direction(arg_info) == GI_DIRECTION_INOUT) {
-        rb_gi_inout_argument_free(rb_argument, argument, &type_info);
-    } else {
-        rb_gi_value_argument_free(rb_argument, argument, &type_info);
+    may_return_null = g_callable_info_may_return_null(callable_info);
+    if (may_return_null && !argument->v_pointer) {
+        return Qnil;
+    }
+    g_callable_info_load_return_type(callable_info, &return_value_info);
+    rb_argument = rb_gi_argument_to_ruby(argument, FALSE, &return_value_info,
+                                         in_args, out_args, args_metadata);
+    switch (g_callable_info_get_caller_owns(callable_info)) {
+    case GI_TRANSFER_NOTHING:
+        break;
+    case GI_TRANSFER_CONTAINER:
+        rb_gi_return_argument_free_container(argument, &return_value_info);
+        break;
+    case GI_TRANSFER_EVERYTHING:
+        rb_gi_return_argument_free_everything(argument, &return_value_info);
+        break;
+    default:
+        g_assert_not_reached();
+        break;
     }
+    return rb_argument;
 }
 void