gobject-introspection 3.4.9 → 4.0.0

data/ext/gobject-introspection/rb-gi-callable-info.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2021  Ruby-GNOME Project Team
+ *  Copyright (C) 2012-2022  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
@@ -48,7 +48,7 @@ rg_return_type(VALUE self)
     GICallableInfo *info;
 
     info = SELF(self);
-    return GI_BASE_INFO2RVAL(g_callable_info_get_return_type(info));
+    return GI_BASE_INFO2RVAL_WITH_UNREF(g_callable_info_get_return_type(info));
 }
 
 static VALUE

data/ext/gobject-introspection/rb-gi-callback.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2021  Ruby-GNOME Project Team
+ *  Copyright (C) 2012-2022  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
@@ -20,6 +20,21 @@
 
 #include "rb-gi-private.h"
 
+#if !GI_CHECK_VERSION(1, 72, 0)
+#  define g_callable_info_create_closure(callable_info,                 \
+                                         cif,                           \
+                                         callback,                      \
+                                         user_data)                     \
+    g_callable_info_prepare_closure((callable_info),                    \
+                                    (cif),                              \
+                                    (callback),                         \
+                                    (user_data))
+#  define g_callable_info_destroy_closure(callable_info,                \
+                                          closure)                      \
+    g_callable_info_free_closure((callable_info),                       \
+                                 (closure))
+#endif
+
 struct RBGICallbackData_ {
     RBGICallback *callback;
     RBGIArgMetadata *metadata;
@@ -37,14 +52,13 @@ typedef struct {
 } RBGICallbackInvokeData;
 
 static GPtrArray *callback_finders;
-static VALUE mGLibObject = Qnil;
 static VALUE mGI = Qnil;
 
 static VALUE
 rb_gi_callback_invoke_without_protect(VALUE user_data)
 {
     RBGICallbackInvokeData *data = (RBGICallbackInvokeData *)user_data;
-    VALUE rb_args = rb_gi_arguments_in_to_ruby(data->args);
+    VALUE rb_args = rb_gi_arguments_get_rb_in_args(data->args);
 
     if (data->callback->method_name) {
         ID id___send__;
@@ -91,6 +105,9 @@ rb_gi_callback_invoke(VALUE user_data)
                &state);
     if (state != 0) {
         VALUE error = rb_errinfo();
+        if (!g_callable_info_can_throw_gerror(data->args->info)) {
+            rbgutil_on_callback_error(error);
+        }
         rb_gi_arguments_fill_raw_out_gerror(data->args, error);
         rb_protect(rb_gi_callback_invoke_fill_raw_results,
                    user_data,
@@ -101,7 +118,11 @@ rb_gi_callback_invoke(VALUE user_data)
                    &state);
         if (state != 0) {
             VALUE error = rb_errinfo();
+            if (!g_callable_info_can_throw_gerror(data->args->info)) {
+                rbgutil_on_callback_error(error);
+            }
             rb_gi_arguments_fill_raw_out_gerror(data->args, error);
+            memset(data->return_value, 0, sizeof(GIFFIReturnValue));
         }
     }
     return Qnil;
@@ -179,18 +200,18 @@ rb_gi_callback_new(GICallbackInfo *callback_info,
     g_base_info_ref(callback->callback_info);
     callback->method_name = g_strdup(method_name);
     callback->closure =
-        g_callable_info_prepare_closure(callback->callback_info,
-                                        &(callback->cif),
-                                        rb_gi_ffi_closure_callback,
-                                        callback);
+        g_callable_info_create_closure(callback->callback_info,
+                                       &(callback->cif),
+                                       rb_gi_ffi_closure_callback,
+                                       callback);
     return callback;
 }
 
 static void
 rb_gi_callback_free(RBGICallback *callback)
 {
-    g_callable_info_free_closure(callback->callback_info,
-                                 callback->closure);
+    g_callable_info_destroy_closure(callback->callback_info,
+                                    callback->closure);
     g_free(callback->method_name);
     g_base_info_unref(callback->callback_info);
     xfree(callback);
@@ -226,14 +247,14 @@ rb_gi_callback_data_new(RBGIArguments *args,
     if (NIL_P(rb_owner)) {
         /* Module function case. */
         VALUE rb_first_argument = RARRAY_AREF(args->rb_args, 0);
-        if (RVAL2CBOOL(rb_obj_is_kind_of(rb_first_argument, mGLibObject))) {
+        if (RVAL2CBOOL(rb_obj_is_kind_of(rb_first_argument, rbg_cGLibObject()))) {
             /* If the first argument of the module function call is
                GObject, it's suitable for owner.
                For example: pango_cairo_context_set_shape_renderer() */
             rb_owner = rb_first_argument;
         }
     }
-    if (RVAL2CBOOL(rb_obj_is_kind_of(rb_owner, mGLibObject))) {
+    if (RVAL2CBOOL(rb_obj_is_kind_of(rb_owner, rbg_cGLibObject()))) {
         rbgobj_object_add_relative(rb_owner, callback_data->rb_callback);
         callback_data->owner = RVAL2GOBJ(rb_owner);
         g_object_weak_ref(callback_data->owner,
@@ -278,7 +299,7 @@ rb_gi_callback_data_free(RBGICallbackData *callback_data)
                                (ID)0,
                                callback_data->rb_callback);
     }
-    xfree(callback_data->metadata);
+    rb_gi_arg_metadata_free(callback_data->metadata);
     xfree(callback_data);
 }
 
@@ -391,6 +412,5 @@ rb_gi_callback_init(VALUE rb_mGI)
     callback_finders = g_ptr_array_new();
     rb_gi_callback_register_finder(source_func_callback_finder);
 
-    mGLibObject = rb_const_get(mGLib, rb_intern("Object"));
     mGI = rb_mGI;
 }

data/ext/gobject-introspection/rb-gi-constant-info.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2018  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2012-2022  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
@@ -47,17 +47,21 @@ rg_type(VALUE self)
 static VALUE
 rg_value(VALUE self)
 {
-    GIConstantInfo *info;
+    GIConstantInfo *info = SELF(self);
     GIArgument value;
-    G_GNUC_UNUSED gint value_size;
-    GITypeInfo *type_info;
-    VALUE rb_value;
+    G_GNUC_UNUSED gint value_size = g_constant_info_get_value(info, &value);
 
-    info = SELF(self);
-    type_info = g_constant_info_get_type(info);
-    value_size = g_constant_info_get_value(info, &value);
-    rb_value = GI_ARGUMENT2RVAL(&value, FALSE, type_info, NULL, NULL, NULL);
-    g_base_info_unref(type_info);
+    RBGIArguments args;
+    rb_gi_arguments_init(&args, NULL, Qnil, Qnil, NULL);
+    RBGIArgMetadata value_metadata;
+    rb_gi_arg_metadata_init_type_info(&value_metadata,
+                                      g_constant_info_get_type(info));
+    VALUE rb_value = rb_gi_arguments_convert_arg(&args,
+                                                 &value,
+                                                 &value_metadata,
+                                                 FALSE);
+    rb_gi_arg_metadata_clear(&value_metadata);
+    rb_gi_arguments_clear(&args);
     g_constant_info_free_value(info, &value);
 
     return rb_value;

data/ext/gobject-introspection/rb-gi-conversions.h

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2021  Ruby-GNOME Project Team
+ *  Copyright (C) 2012-2022  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
@@ -30,16 +30,6 @@
     (rb_gi_base_info_to_ruby_with_unref((GIBaseInfo *)(info)))
 #define RVAL2GI_BASE_INFO(rb_object) (rb_gi_base_info_from_ruby(rb_object))
 
-#define GI_ARGUMENT2RVAL(argument, duplicate, type_info,                \
-                         in_args, out_args, args_metadata)              \
-    (rb_gi_argument_to_ruby((argument), (duplicate), (type_info),       \
-                            (in_args), (out_args), (args_metadata)))
-#define GI_RETURN_ARGUMENT2RVAL(callable_info, argument,                \
-                                in_args, out_args, args_metadata)       \
-    (rb_gi_return_argument_to_ruby((callable_info), (argument),         \
-                                   (in_args), (out_args), (args_metadata)))
-
-
 #define RVAL2GI_REGISTERED_TYPE_INFO(rb_object)			\
     ((GIRegisteredTypeInfo *)RVAL2GI_BASE_INFO(rb_object))
 #define RVAL2GI_FUNCTION_INFO(rb_object)			\
@@ -90,16 +80,4 @@ VALUE       rb_gi_base_info_to_ruby           (GIBaseInfo *info);
 VALUE       rb_gi_base_info_to_ruby_with_unref(GIBaseInfo *info);
 GIBaseInfo *rb_gi_base_info_from_ruby         (VALUE rb_info);
 
-VALUE       rb_gi_argument_to_ruby            (GIArgument     *argument,
-                                               gboolean        duplicate,
-                                               GITypeInfo     *type_info,
-                                               GArray         *in_args,
-                                               GArray         *out_args,
-                                               GPtrArray      *args_metadata);
-VALUE       rb_gi_return_argument_to_ruby     (GICallableInfo *callable_info,
-                                               GIArgument     *argument,
-                                               GArray         *in_args,
-                                               GArray         *out_args,
-                                               GPtrArray      *args_metadata);
-
 VALUE       rb_gi_array_type_to_ruby          (GIArrayType type);

data/ext/gobject-introspection/rb-gi-field-info.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2013  Ruby-GNOME2 Project Team
+ *  Copyright (C) 2012-2022  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
@@ -71,66 +71,58 @@ rg_type(VALUE self)
     return GI_BASE_INFO2RVAL_WITH_UNREF(g_field_info_get_type(info));
 }
 
+typedef struct {
+    RBGIArguments args;
+    GIArgument value;
+    RBGIArgMetadata metadata;
+    GIFieldInfo *info;
+    gpointer memory;
+} FieldToRubyData;
+
 static VALUE
-rb_gi_field_info_get_field_raw_interface(GIFieldInfo *info,
-                                         gpointer memory,
-                                         GITypeInfo *type_info)
+rb_gi_field_info_get_field_raw_body_interface(FieldToRubyData *data)
 {
-    VALUE rb_field_value = Qnil;
-    GIBaseInfo *interface_info;
-    GIInfoType interface_type;
-    GType gtype;
-    gint offset;
-
-    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);
-    offset = g_field_info_get_offset(info);
-    switch (interface_type) {
+    GIInfoType type = data->metadata.type.interface_type;
+    GType gtype = data->metadata.type.interface_gtype;
+    gint offset = g_field_info_get_offset(data->info);
+    switch (type) {
       case GI_INFO_TYPE_INVALID:
       case GI_INFO_TYPE_FUNCTION:
       case GI_INFO_TYPE_CALLBACK:
         rb_raise(rb_eNotImpError,
                  "TODO: GIField(interface)[%s](%s)",
-                 g_info_type_to_string(interface_type),
+                 g_info_type_to_string(type),
                  g_type_name(gtype));
-        break;
+        return Qnil;
       case GI_INFO_TYPE_STRUCT:
         {
-            GIStructInfo *struct_info = (GIStructInfo *)interface_info;
-            gboolean is_pointer;
-            gpointer target;
-
-            is_pointer = g_type_info_is_pointer(type_info);
-            target = (gpointer)((guint8 *)memory + offset);
+            GIStructInfo *struct_info =
+                (GIStructInfo *)(data->metadata.type.interface_info);
+            gboolean is_pointer =
+                g_type_info_is_pointer(data->metadata.type.info);
+            gpointer target = (gpointer)((guint8 *)(data->memory) + offset);
             if (is_pointer) {
                 target = *((gpointer *)target);
             }
-            rb_field_value = rb_gi_struct_info_to_ruby(struct_info,
-                                                       target,
-                                                       is_pointer);
-            break;
+            return rb_gi_struct_info_to_ruby(struct_info, target, is_pointer);
         }
       case GI_INFO_TYPE_BOXED:
       case GI_INFO_TYPE_UNION:
       case GI_INFO_TYPE_OBJECT:
-        {
-            GIArgument argument;
-
-            argument.v_pointer = G_STRUCT_MEMBER(gpointer, memory, offset);
-            rb_field_value = GI_ARGUMENT2RVAL(&argument, FALSE, type_info,
-                                              NULL, NULL, NULL);
-        }
-        break;
+        data->value.v_pointer = G_STRUCT_MEMBER(gpointer, data->memory, offset);
+        return rb_gi_arguments_convert_arg(&(data->args),
+                                           &(data->value),
+                                           &(data->metadata),
+                                           FALSE);
       case GI_INFO_TYPE_ENUM:
         {
             gint32 raw_value;
 
-            raw_value = G_STRUCT_MEMBER(gint32, memory, offset);
+            raw_value = G_STRUCT_MEMBER(gint32, data->memory, offset);
             if (gtype == G_TYPE_NONE) {
-                rb_field_value = INT2NUM(raw_value);
+                return INT2NUM(raw_value);
             } else {
-                rb_field_value = GENUM2RVAL(raw_value, gtype);
+                return GENUM2RVAL(raw_value, gtype);
             }
         }
         break;
@@ -138,11 +130,11 @@ rb_gi_field_info_get_field_raw_interface(GIFieldInfo *info,
         {
             gint32 raw_value;
 
-            raw_value = G_STRUCT_MEMBER(gint32, memory, offset);
+            raw_value = G_STRUCT_MEMBER(gint32, data->memory, offset);
             if (gtype == G_TYPE_NONE) {
-                rb_field_value = INT2NUM(raw_value);
+                return INT2NUM(raw_value);
             } else {
-                rb_field_value = GFLAGS2RVAL(raw_value, gtype);
+                return GFLAGS2RVAL(raw_value, gtype);
             }
         }
         break;
@@ -157,32 +149,21 @@ rb_gi_field_info_get_field_raw_interface(GIFieldInfo *info,
       case GI_INFO_TYPE_ARG:
       case GI_INFO_TYPE_TYPE:
       case GI_INFO_TYPE_UNRESOLVED:
+      default:
         rb_raise(rb_eNotImpError,
                  "TODO: GIField(interface)[%s](%s)",
-                 g_info_type_to_string(interface_type),
+                 g_info_type_to_string(type),
                  g_type_name(gtype));
-        break;
-      default:
-        break;
+        return Qnil;
     }
-    g_base_info_unref(interface_info);
-
-    return rb_field_value;
 }
 
-VALUE
-rb_gi_field_info_get_field_raw(GIFieldInfo *info, gpointer memory)
+static VALUE
+rb_gi_field_info_get_field_raw_body(VALUE user_data)
 {
-    GIArgument argument;
+    FieldToRubyData *data = (FieldToRubyData *)user_data;
     gboolean processed = FALSE;
-    GITypeInfo *type_info;
-    GITypeTag type_tag;
-    VALUE rb_field_value = Qnil;
-
-    type_info = g_field_info_get_type(info);
-    type_tag = g_type_info_get_tag(type_info);
-
-    switch (type_tag) {
+    switch (data->metadata.type.tag) {
       case GI_TYPE_TAG_VOID:
       case GI_TYPE_TAG_BOOLEAN:
       case GI_TYPE_TAG_INT8:
@@ -200,8 +181,9 @@ rb_gi_field_info_get_field_raw(GIFieldInfo *info, gpointer memory)
       case GI_TYPE_TAG_UTF8:
         {
             int offset;
-            offset = g_field_info_get_offset(info);
-            argument.v_string = G_STRUCT_MEMBER(gchar *, memory, offset);
+            offset = g_field_info_get_offset(data->info);
+            data->value.v_string =
+                G_STRUCT_MEMBER(gchar *, data->memory, offset);
             processed = TRUE;
         }
         break;
@@ -209,13 +191,11 @@ rb_gi_field_info_get_field_raw(GIFieldInfo *info, gpointer memory)
       case GI_TYPE_TAG_ARRAY:
         break;
       case GI_TYPE_TAG_INTERFACE:
-        rb_field_value =
-            rb_gi_field_info_get_field_raw_interface(info,
-                                                     memory,
-                                                     type_info);
-        if (!NIL_P(rb_field_value)) {
-            g_base_info_unref(type_info);
-            return rb_field_value;
+        {
+            VALUE rb_value = rb_gi_field_info_get_field_raw_body_interface(data);
+            if (!NIL_P(rb_value)) {
+                return rb_value;
+            }
         }
         break;
       case GI_TYPE_TAG_GLIST:
@@ -229,19 +209,40 @@ rb_gi_field_info_get_field_raw(GIFieldInfo *info, gpointer memory)
     }
 
     if (!processed) {
-        if (!g_field_info_get_field(info, memory, &argument)) {
-            g_base_info_unref(type_info);
+        if (!g_field_info_get_field(data->info, data->memory, &(data->value))) {
             rb_raise(rb_eArgError, "failed to get field value: %s[%s]",
-                     g_base_info_get_name(info),
-                     g_type_tag_to_string(type_tag));
+                     g_base_info_get_name(data->info),
+                     g_type_tag_to_string(data->metadata.type.tag));
         }
     }
 
-    rb_field_value = GI_ARGUMENT2RVAL(&argument, FALSE, type_info,
-                                      NULL, NULL, NULL);
-    g_base_info_unref(type_info);
+    return rb_gi_arguments_convert_arg(&(data->args),
+                                       &(data->value),
+                                       &(data->metadata),
+                                       FALSE);
+}
 
-    return rb_field_value;
+static VALUE
+rb_gi_field_info_get_field_raw_ensure(VALUE user_data)
+{
+    FieldToRubyData *data = (FieldToRubyData *)user_data;
+    rb_gi_arguments_clear(&(data->args));
+    rb_gi_arg_metadata_clear(&(data->metadata));
+    return Qnil;
+}
+
+VALUE
+rb_gi_field_info_get_field_raw(GIFieldInfo *info, gpointer memory)
+{
+    FieldToRubyData data;
+    rb_gi_arguments_init(&(data.args), NULL, Qnil, Qnil, NULL);
+    GITypeInfo *type_info = g_field_info_get_type(info);
+    rb_gi_arg_metadata_init_type_info(&(data.metadata), type_info);
+    data.info = info;
+    data.memory = memory;
+
+    return rb_ensure(rb_gi_field_info_get_field_raw_body, (VALUE)&data,
+                     rb_gi_field_info_get_field_raw_ensure, (VALUE)&data);
 }
 
 void

data/ext/gobject-introspection/rb-gi-function-info.c

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2012-2019  Ruby-GNOME Project Team
+ *  Copyright (C) 2012-2022  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
@@ -49,18 +49,55 @@ gi_function_info_get_type(void)
 }
 
 static VALUE
-rg_set_unlock_gvl(VALUE self, VALUE rb_boolean)
+rg_set_lock_gvl_default(VALUE self, VALUE rb_boolean)
 {
-    return rb_iv_set(self, "unlock_gvl", rb_boolean);
+    return rb_iv_set(self, "lock_gvl_default", rb_boolean);
 }
 
 static VALUE
-rg_unlock_gvl_p(VALUE self)
+rg_add_lock_gvl_predicate(VALUE self)
 {
-    if (!RVAL2CBOOL(rb_ivar_defined(self, rb_intern("unlock_gvl")))) {
-        rb_iv_set(self, "unlock_gvl", Qfalse);
+    VALUE rb_predicates;
+    if (!RVAL2CBOOL(rb_ivar_defined(self, rb_intern("lock_gvl_predicates")))) {
+        rb_predicates = rb_ary_new();
+        rb_iv_set(self, "lock_gvl_predicates", rb_predicates);
+    } else {
+        rb_predicates = rb_iv_get(self, "lock_gvl_predicates");
+    }
+    rb_ary_push(rb_predicates, rb_block_lambda());
+    return Qnil;
+}
+
+static VALUE
+rg_lock_gvl_p(int argc, VALUE *argv, VALUE self)
+{
+    VALUE rb_receiver;
+    VALUE rb_lock_gvl_default = Qtrue;
+    rb_scan_args(argc, argv, "01", &rb_receiver);
+    if (RVAL2CBOOL(rb_ivar_defined(self, rb_intern("lock_gvl_default")))) {
+        rb_lock_gvl_default = rb_iv_get(self, "lock_gvl_default");
+    }
+    if (NIL_P(rb_receiver)) {
+        return rb_lock_gvl_default;
     }
-    return rb_iv_get(self, "unlock_gvl");
+    if (!RVAL2CBOOL(rb_ivar_defined(self, rb_intern("lock_gvl_predicates")))) {
+        return rb_lock_gvl_default;
+    }
+    VALUE rb_predicates = rb_iv_get(self, "lock_gvl_predicates");
+    long n = RARRAY_LEN(rb_predicates);
+    long i;
+    VALUE rb_args = rb_ary_new_from_args(2,
+                                         self,
+                                         rb_receiver);
+    for (i = 0; i < n; i++) {
+        VALUE rb_predicate = RARRAY_PTR(rb_predicates)[n - i - 1];
+        VALUE rb_result = rb_proc_call(rb_predicate, rb_args);
+        if (NIL_P(rb_result)) {
+            continue;
+        }
+        return rb_result;
+    }
+    return rb_lock_gvl_default;
 }
 
 static VALUE
@@ -144,9 +181,12 @@ rb_gi_function_info_invoke_raw(GIFunctionInfo *info,
     VALUE rb_out_args = Qnil;
     gboolean succeeded;
     GError *error = NULL;
-    gboolean unlock_gvl = FALSE;
+    gboolean lock_gvl = FALSE;
 
-    unlock_gvl = RVAL2CBOOL(rb_funcall(rb_info, rb_intern("unlock_gvl?"), 0));
+    lock_gvl = RVAL2CBOOL(rb_funcall(rb_info,
+                                     rb_intern("lock_gvl?"),
+                                     1,
+                                     rb_receiver));
     rb_arguments = rbg_to_array(rb_arguments);
 
     callable_info = (GICallableInfo *)info;
@@ -161,12 +201,12 @@ rb_gi_function_info_invoke_raw(GIFunctionInfo *info,
         data.in_args = args.in_args;
         data.out_args = args.out_args;
         data.error = &error;
-        if (unlock_gvl) {
+        if (lock_gvl) {
+            rb_gi_function_info_invoke_raw_call(&data);
+        } else {
             rb_thread_call_without_gvl(
                 rb_gi_function_info_invoke_raw_call_without_gvl_body, &data,
                 NULL, NULL);
-        } else {
-            rb_gi_function_info_invoke_raw_call(&data);
         }
         succeeded = data.succeeded;
 
@@ -176,8 +216,8 @@ rb_gi_function_info_invoke_raw(GIFunctionInfo *info,
         if (rb_return_value) {
             if (succeeded) {
                 *rb_return_value =
-                    rb_gi_arguments_get_rb_return_value(&args,
-                                                        &(data.return_value));
+                    rb_gi_arguments_convert_return_value(&args,
+                                                         &(data.return_value));
             } else {
                 *rb_return_value = Qnil;
             }
@@ -243,8 +283,9 @@ rb_gi_function_info_init(VALUE rb_mGI, VALUE rb_cGICallableInfo)
 	G_DEF_CLASS_WITH_PARENT(GI_TYPE_FUNCTION_INFO, "FunctionInfo", rb_mGI,
 				rb_cGICallableInfo);
 
-    RG_DEF_METHOD(set_unlock_gvl, 1);
-    RG_DEF_METHOD_P(unlock_gvl, 0);
+    RG_DEF_METHOD(set_lock_gvl_default, 1);
+    RG_DEF_METHOD(add_lock_gvl_predicate, 0);
+    RG_DEF_METHOD_P(lock_gvl, -1);
 
     RG_DEF_METHOD(symbol, 0);
     RG_DEF_METHOD(flags, 0);

data/ext/gobject-introspection/rb-gi-private-arg-info.h

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2019  Ruby-GNOME Project Team
+ *  Copyright (C) 2019-2022  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
@@ -20,5 +20,7 @@
 
 #pragma once
 
+G_GNUC_INTERNAL gboolean
+rb_gi_arg_info_is_input_buffer(GIArgInfo *info);
 G_GNUC_INTERNAL gboolean
 rb_gi_arg_info_is_output_buffer(GIArgInfo *info);

data/ext/gobject-introspection/rb-gi-private-arguments.h

@@ -1,6 +1,6 @@
 /* -*- c-file-style: "ruby"; indent-tabs-mode: nil -*- */
 /*
- *  Copyright (C) 2019-2021  Ruby-GNOME Project Team
+ *  Copyright (C) 2019-2022  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
@@ -50,6 +50,7 @@ typedef struct {
 struct RBGIArgMetadata_ {
     GICallableInfo *callable_info;
     GIArgInfo arg_info;
+    GITypeInfo *type_info;
     const gchar *name;
     RBGIArgMetadataType type;
     RBGIArgMetadataType element_type;
@@ -67,6 +68,7 @@ struct RBGIArgMetadata_ {
     gboolean may_be_null_p;
     gboolean caller_allocates_p;
     gboolean zero_terminated_p;
+    gboolean input_buffer_p;
     gboolean output_buffer_p;
     GIArrayType array_type;
     gint index;
@@ -85,6 +87,14 @@ struct RBGIArgMetadata_ {
     gpointer free_func_data;
 };
 
+G_GNUC_INTERNAL void
+rb_gi_arg_metadata_init_type_info(RBGIArgMetadata *metadata,
+                                  GITypeInfo *type_info);
+G_GNUC_INTERNAL void
+rb_gi_arg_metadata_clear(RBGIArgMetadata *metadata);
+G_GNUC_INTERNAL void
+rb_gi_arg_metadata_free(RBGIArgMetadata *metadata);
+
 G_GNUC_INTERNAL void
 rb_gi_arguments_init(RBGIArguments *args,
                      GICallableInfo *info,
@@ -94,12 +104,20 @@ rb_gi_arguments_init(RBGIArguments *args,
 G_GNUC_INTERNAL void
 rb_gi_arguments_clear(RBGIArguments *args);
 
+G_GNUC_INTERNAL VALUE
+rb_gi_arguments_get_rb_in_args(RBGIArguments *args);
 G_GNUC_INTERNAL VALUE
 rb_gi_arguments_get_rb_out_args(RBGIArguments *args);
 
 G_GNUC_INTERNAL VALUE
-rb_gi_arguments_get_rb_return_value(RBGIArguments *args,
-                                    GIArgument *return_value);
+rb_gi_arguments_convert_arg(RBGIArguments *args,
+                            GIArgument *arg,
+                            RBGIArgMetadata *arg_metadata,
+                            gboolean duplicate);
+
+G_GNUC_INTERNAL VALUE
+rb_gi_arguments_convert_return_value(RBGIArguments *args,
+                                     GIArgument *return_value);
 
 G_GNUC_INTERNAL void
 rb_gi_arguments_fill_raw_out_gerror(RBGIArguments *args,