LCOV - code coverage report
Current view: top level - gi - function.cpp (source / functions) Coverage Total Hit
Test: gjs- Code Coverage Lines: 79.0 % 677 535
Test Date: 2025-05-07 12:25:00 Functions: 74.0 % 50 37
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 73.5 % 442 325

             Branch data     Line data    Source code
       1                 :             : /* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; -*- */
       2                 :             : // SPDX-License-Identifier: MIT OR LGPL-2.0-or-later
       3                 :             : // SPDX-FileCopyrightText: 2008 litl, LLC
       4                 :             : 
       5                 :             : #include <config.h>
       6                 :             : 
       7                 :             : #include <stddef.h>  // for NULL, size_t
       8                 :             : #include <stdint.h>
       9                 :             : 
      10                 :             : #include <limits>
      11                 :             : #include <memory>  // for unique_ptr
      12                 :             : #include <sstream>
      13                 :             : #include <string>
      14                 :             : #include <vector>
      15                 :             : 
      16                 :             : #include <ffi.h>
      17                 :             : #include <girepository.h>
      18                 :             : #include <girffi.h>
      19                 :             : #include <glib-object.h>
      20                 :             : #include <glib.h>
      21                 :             : 
      22                 :             : #include <js/Array.h>
      23                 :             : #include <js/CallAndConstruct.h>  // for IsCallable
      24                 :             : #include <js/CallArgs.h>
      25                 :             : #include <js/Class.h>
      26                 :             : #include <js/ErrorReport.h>  // for JS_ReportOutOfMemory
      27                 :             : #include <js/Exception.h>
      28                 :             : #include <js/HeapAPI.h>  // for RuntimeHeapIsCollecting
      29                 :             : #include <js/PropertyAndElement.h>
      30                 :             : #include <js/PropertyDescriptor.h>  // for JSPROP_PERMANENT
      31                 :             : #include <js/PropertySpec.h>
      32                 :             : #include <js/Realm.h>  // for GetRealmFunctionPrototype
      33                 :             : #include <js/RootingAPI.h>
      34                 :             : #include <js/TypeDecls.h>
      35                 :             : #include <js/Value.h>
      36                 :             : #include <js/ValueArray.h>
      37                 :             : #include <js/Warnings.h>
      38                 :             : #include <jsapi.h>    // for HandleValueArray
      39                 :             : #include <jspubtd.h>  // for JSProtoKey
      40                 :             : #include <mozilla/Maybe.h>
      41                 :             : 
      42                 :             : #include "gi/arg-cache.h"
      43                 :             : #include "gi/arg-inl.h"
      44                 :             : #include "gi/arg-types-inl.h"
      45                 :             : #include "gi/arg.h"
      46                 :             : #include "gi/closure.h"
      47                 :             : #include "gi/cwrapper.h"
      48                 :             : #include "gi/function.h"
      49                 :             : #include "gi/gerror.h"
      50                 :             : #include "gi/object.h"
      51                 :             : #include "gi/utils-inl.h"
      52                 :             : #include "gjs/auto.h"
      53                 :             : #include "gjs/context-private.h"
      54                 :             : #include "gjs/gerror-result.h"
      55                 :             : #include "gjs/global.h"
      56                 :             : #include "gjs/jsapi-util.h"
      57                 :             : #include "gjs/macros.h"
      58                 :             : #include "gjs/mem-private.h"
      59                 :             : #include "gjs/profiler-private.h"
      60                 :             : #include "util/log.h"
      61                 :             : 
      62                 :             : using mozilla::Maybe, mozilla::Some;
      63                 :             : 
      64                 :             : /* We use guint8 for arguments; functions can't
      65                 :             :  * have more than this.
      66                 :             :  */
      67                 :             : #define GJS_ARG_INDEX_INVALID G_MAXUINT8
      68                 :             : 
      69                 :             : namespace Gjs {
      70                 :             : 
      71                 :             : class Function : public CWrapper<Function> {
      72                 :             :     friend CWrapperPointerOps<Function>;
      73                 :             :     friend CWrapper<Function>;
      74                 :             : 
      75                 :             :     static constexpr auto PROTOTYPE_SLOT = GjsGlobalSlot::PROTOTYPE_function;
      76                 :             :     static constexpr GjsDebugTopic DEBUG_TOPIC = GJS_DEBUG_GFUNCTION;
      77                 :             : 
      78                 :             :     GI::AutoCallableInfo m_info;
      79                 :             : 
      80                 :             :     ArgsCache m_arguments;
      81                 :             : 
      82                 :             :     uint8_t m_js_in_argc;
      83                 :             :     uint8_t m_js_out_argc;
      84                 :             :     GIFunctionInvoker m_invoker;
      85                 :             : 
      86                 :       11926 :     explicit Function(GICallableInfo* info)
      87                 :       11926 :         : m_info(info, Gjs::TakeOwnership{}),
      88                 :       11926 :           m_js_in_argc(0),
      89                 :       11926 :           m_js_out_argc(0),
      90                 :       11926 :           m_invoker({}) {
      91                 :       11926 :         GJS_INC_COUNTER(function);
      92                 :       11926 :     }
      93                 :             :     ~Function();
      94                 :             : 
      95                 :             :     GJS_JSAPI_RETURN_CONVENTION
      96                 :             :     bool init(JSContext* cx, GType gtype = G_TYPE_NONE);
      97                 :             : 
      98                 :             :     /**
      99                 :             :      * Like CWrapperPointerOps::for_js_typecheck(), but additionally checks that
     100                 :             :      * the pointer is not null, which is the case for prototype objects.
     101                 :             :      */
     102                 :             :     GJS_JSAPI_RETURN_CONVENTION
     103                 :          20 :     static bool for_js_instance(JSContext* cx, JS::HandleObject obj,
     104                 :             :                                 Function** out, JS::CallArgs* args) {
     105                 :             :         Function* priv;
     106         [ -  + ]:          20 :         if (!Function::for_js_typecheck(cx, obj, &priv, args))
     107                 :           0 :             return false;
     108         [ -  + ]:          20 :         if (!priv) {
     109                 :             :             // This is the prototype
     110                 :           0 :             gjs_throw(cx, "Impossible on prototype; only on instances");
     111                 :           0 :             return false;
     112                 :             :         }
     113                 :          20 :         *out = priv;
     114                 :          20 :         return true;
     115                 :             :     }
     116                 :             : 
     117                 :             :     GJS_JSAPI_RETURN_CONVENTION
     118                 :             :     static bool call(JSContext* cx, unsigned argc, JS::Value* vp);
     119                 :             : 
     120                 :             :     static void finalize_impl(JS::GCContext*, Function* priv);
     121                 :             : 
     122                 :             :     GJS_JSAPI_RETURN_CONVENTION
     123                 :             :     static bool get_length(JSContext* cx, unsigned argc, JS::Value* vp);
     124                 :             : 
     125                 :             :     GJS_JSAPI_RETURN_CONVENTION
     126                 :             :     static bool to_string(JSContext* cx, unsigned argc, JS::Value* vp);
     127                 :             : 
     128                 :             :     GJS_JSAPI_RETURN_CONVENTION
     129                 :             :     bool to_string_impl(JSContext* cx, JS::MutableHandleValue rval);
     130                 :             : 
     131                 :             :     GJS_JSAPI_RETURN_CONVENTION
     132                 :             :     bool finish_invoke(JSContext* cx, const JS::CallArgs& args,
     133                 :             :                        GjsFunctionCallState* state,
     134                 :             :                        GIArgument* r_value = nullptr);
     135                 :             : 
     136                 :             :     GJS_JSAPI_RETURN_CONVENTION
     137                 :          63 :     static JSObject* inherit_builtin_function(JSContext* cx, JSProtoKey) {
     138                 :             :         JS::RootedObject builtin_function_proto(
     139                 :          63 :             cx, JS::GetRealmFunctionPrototype(cx));
     140                 :          63 :         return JS_NewObjectWithGivenProto(cx, nullptr, builtin_function_proto);
     141                 :          63 :     }
     142                 :             : 
     143                 :             :     static const JSClassOps class_ops;
     144                 :             :     static const JSPropertySpec proto_props[];
     145                 :             :     static const JSFunctionSpec proto_funcs[];
     146                 :             : 
     147                 :             :     static constexpr js::ClassSpec class_spec = {
     148                 :             :         nullptr,  // createConstructor
     149                 :             :         &Function::inherit_builtin_function,
     150                 :             :         nullptr,  // constructorFunctions
     151                 :             :         nullptr,  // constructorProperties
     152                 :             :         Function::proto_funcs,
     153                 :             :         Function::proto_props,
     154                 :             :         nullptr,  // finishInit
     155                 :             :         js::ClassSpec::DontDefineConstructor};
     156                 :             : 
     157                 :             :     static constexpr JSClass klass = {
     158                 :             :         "GIRepositoryFunction",
     159                 :             :         JSCLASS_HAS_RESERVED_SLOTS(1) | JSCLASS_BACKGROUND_FINALIZE,
     160                 :             :         &Function::class_ops, &Function::class_spec};
     161                 :             : 
     162                 :             :  public:
     163                 :             :     GJS_JSAPI_RETURN_CONVENTION
     164                 :             :     static JSObject* create(JSContext* cx, GType gtype, GICallableInfo* info);
     165                 :             : 
     166                 :             :     [[nodiscard]] std::string format_name();
     167                 :             : 
     168                 :             :     GJS_JSAPI_RETURN_CONVENTION
     169                 :             :     bool invoke(JSContext* cx, const JS::CallArgs& args,
     170                 :             :                 JS::HandleObject this_obj = nullptr,
     171                 :             :                 GIArgument* r_value = nullptr);
     172                 :             : 
     173                 :             :     GJS_JSAPI_RETURN_CONVENTION
     174                 :          21 :     static bool invoke_constructor_uncached(JSContext* cx, GIFunctionInfo* info,
     175                 :             :                                             JS::HandleObject obj,
     176                 :             :                                             const JS::CallArgs& args,
     177                 :             :                                             GIArgument* rvalue) {
     178                 :          21 :         Function function(info);
     179         [ -  + ]:          21 :         if (!function.init(cx))
     180                 :           0 :             return false;
     181                 :          21 :         return function.invoke(cx, args, obj, rvalue);
     182                 :          21 :     }
     183                 :             : };
     184                 :             : 
     185                 :             : }  // namespace Gjs
     186                 :             : 
     187                 :             : template <typename TAG>
     188                 :         570 : static inline void set_ffi_arg(void* result, GIArgument* value) {
     189                 :             :     using T = Gjs::Tag::RealT<TAG>;
     190                 :             :     if constexpr (std::is_integral_v<T> && std::is_signed_v<T>) {
     191                 :         475 :         *static_cast<ffi_sarg*>(result) = gjs_arg_get<TAG>(value);
     192                 :             :     } else if constexpr (std::is_floating_point_v<T> || std::is_unsigned_v<T>) {
     193                 :           0 :         *static_cast<ffi_arg*>(result) = gjs_arg_get<TAG>(value);
     194                 :             :     } else if constexpr (std::is_pointer_v<T>) {
     195                 :          95 :         *static_cast<ffi_arg*>(result) =
     196                 :          95 :             gjs_pointer_to_int<ffi_arg>(gjs_arg_get<TAG>(value));
     197                 :             :     }
     198                 :         570 : }
     199                 :             : 
     200                 :         570 : static void set_return_ffi_arg_from_gi_argument(GITypeInfo* ret_type,
     201                 :             :                                                 void* result,
     202                 :             :                                                 GIArgument* return_value) {
     203                 :             :     // Be consistent with gjs_value_to_gi_argument()
     204   [ -  -  -  -  :         570 :     switch (g_type_info_get_tag(ret_type)) {
          -  +  -  +  -  
          +  +  -  -  -  
                -  +  - ]
     205                 :           0 :     case GI_TYPE_TAG_VOID:
     206                 :             :         g_assert_not_reached();
     207                 :           0 :     case GI_TYPE_TAG_INT8:
     208                 :           0 :         set_ffi_arg<int8_t>(result, return_value);
     209                 :           0 :         break;
     210                 :           0 :     case GI_TYPE_TAG_UINT8:
     211                 :           0 :         set_ffi_arg<uint8_t>(result, return_value);
     212                 :           0 :         break;
     213                 :           0 :     case GI_TYPE_TAG_INT16:
     214                 :           0 :         set_ffi_arg<int16_t>(result, return_value);
     215                 :           0 :         break;
     216                 :           0 :     case GI_TYPE_TAG_UINT16:
     217                 :           0 :         set_ffi_arg<uint16_t>(result, return_value);
     218                 :           0 :         break;
     219                 :         118 :     case GI_TYPE_TAG_INT32:
     220                 :         118 :         set_ffi_arg<int32_t>(result, return_value);
     221                 :         118 :         break;
     222                 :           0 :     case GI_TYPE_TAG_UINT32:
     223                 :           0 :         set_ffi_arg<uint32_t>(result, return_value);
     224                 :           0 :         break;
     225                 :         185 :     case GI_TYPE_TAG_BOOLEAN:
     226                 :         185 :         set_ffi_arg<Gjs::Tag::GBoolean>(result, return_value);
     227                 :         185 :         break;
     228                 :           0 :     case GI_TYPE_TAG_UNICHAR:
     229                 :           0 :         set_ffi_arg<char32_t>(result, return_value);
     230                 :           0 :         break;
     231                 :          18 :     case GI_TYPE_TAG_INT64:
     232                 :          18 :         set_ffi_arg<int64_t>(result, return_value);
     233                 :          18 :         break;
     234                 :         245 :     case GI_TYPE_TAG_INTERFACE:
     235                 :             :         {
     236                 :             :             GI::AutoBaseInfo interface_info{
     237                 :         245 :                 g_type_info_get_interface(ret_type)};
     238                 :             : 
     239   [ +  +  +  +  :         245 :             if (GI_IS_ENUM_INFO(interface_info))
                   +  + ]
     240                 :         154 :                 set_ffi_arg<Gjs::Tag::Enum>(result, return_value);
     241                 :             :             else
     242                 :          91 :                 set_ffi_arg<void*>(result, return_value);
     243                 :         245 :         }
     244                 :         245 :         break;
     245                 :           0 :     case GI_TYPE_TAG_UINT64:
     246                 :             :         // Other primitive types need to squeeze into 64-bit ffi_arg too
     247                 :           0 :         set_ffi_arg<uint64_t>(result, return_value);
     248                 :           0 :         break;
     249                 :           0 :     case GI_TYPE_TAG_FLOAT:
     250                 :           0 :         set_ffi_arg<float>(result, return_value);
     251                 :           0 :         break;
     252                 :           0 :     case GI_TYPE_TAG_DOUBLE:
     253                 :           0 :         set_ffi_arg<double>(result, return_value);
     254                 :           0 :         break;
     255                 :           0 :     case GI_TYPE_TAG_GTYPE:
     256                 :           0 :         set_ffi_arg<Gjs::Tag::GType>(result, return_value);
     257                 :           0 :         break;
     258                 :           4 :     case GI_TYPE_TAG_UTF8:
     259                 :             :     case GI_TYPE_TAG_FILENAME:
     260                 :           4 :         set_ffi_arg<char*>(result, return_value);
     261                 :           4 :         break;
     262                 :           0 :     case GI_TYPE_TAG_ARRAY:
     263                 :             :     case GI_TYPE_TAG_GLIST:
     264                 :             :     case GI_TYPE_TAG_GSLIST:
     265                 :             :     case GI_TYPE_TAG_GHASH:
     266                 :             :     case GI_TYPE_TAG_ERROR:
     267                 :             :     default:
     268                 :           0 :         set_ffi_arg<void*>(result, return_value);
     269                 :           0 :         break;
     270                 :             :     }
     271                 :         570 : }
     272                 :             : 
     273                 :           4 : void GjsCallbackTrampoline::warn_about_illegal_js_callback(const char* when,
     274                 :             :                                                            const char* reason,
     275                 :             :                                                            bool        dump_stack) {
     276                 :           4 :     std::ostringstream message;
     277                 :             : 
     278                 :             :     message << "Attempting to run a JS callback " << when << ". "
     279                 :             :             << "This is most likely caused by " << reason << ". "
     280                 :           4 :             << "Because it would crash the application, it has been blocked.";
     281         [ +  - ]:           4 :     if (m_info) {
     282                 :             :         message << "\nThe offending callback was " << m_info.name() << "()"
     283         [ +  - ]:           4 :                 << (m_is_vfunc ? ", a vfunc." : ".");
     284                 :             :     }
     285         [ +  - ]:           4 :     if (dump_stack) {
     286                 :           4 :         message << "\n" << gjs_dumpstack_string();
     287                 :             :     }
     288                 :           4 :     g_critical("%s", message.str().c_str());
     289                 :           4 : }
     290                 :             : 
     291                 :             : /* This is our main entry point for ffi_closure callbacks.
     292                 :             :  * ffi_prep_closure is doing pure magic and replaces the original
     293                 :             :  * function call with this one which gives us the ffi arguments,
     294                 :             :  * a place to store the return value and our use data.
     295                 :             :  * In other words, everything we need to call the JS function and
     296                 :             :  * getting the return value back.
     297                 :             :  */
     298                 :         499 : void GjsCallbackTrampoline::callback_closure(GIArgument** args, void* result) {
     299                 :             :     GITypeInfo ret_type;
     300                 :             : 
     301                 :             :     // Fill in the result with some hopefully neutral value
     302                 :         499 :     g_callable_info_load_return_type(m_info, &ret_type);
     303         [ +  + ]:         499 :     if (g_type_info_get_tag(&ret_type) != GI_TYPE_TAG_VOID) {
     304                 :         296 :         GIArgument argument = {};
     305                 :         296 :         gjs_arg_unset(&argument);
     306                 :         296 :         set_return_ffi_arg_from_gi_argument(&ret_type, result, &argument);
     307                 :             :     }
     308                 :             : 
     309         [ -  + ]:         499 :     if (G_UNLIKELY(!is_valid())) {
     310                 :           0 :         warn_about_illegal_js_callback(
     311                 :             :             "during shutdown",
     312                 :             :             "destroying a Clutter actor or GTK widget with ::destroy signal "
     313                 :             :             "connected, or using the destroy(), dispose(), or remove() vfuncs",
     314                 :             :             true);
     315                 :          12 :         return;
     316                 :             :     }
     317                 :             : 
     318                 :         499 :     JSContext* context = this->context();
     319                 :         499 :     GjsContextPrivate* gjs = GjsContextPrivate::from_cx(context);
     320         [ +  + ]:         499 :     if (JS::RuntimeHeapIsCollecting()) {
     321                 :           4 :         warn_about_illegal_js_callback(
     322                 :             :             "during garbage collection",
     323                 :             :             "destroying a Clutter actor or GTK widget with ::destroy signal "
     324                 :             :             "connected, or using the destroy(), dispose(), or remove() vfuncs",
     325                 :             :             true);
     326                 :           4 :         return;
     327                 :             :     }
     328                 :             : 
     329         [ -  + ]:         495 :     if (G_UNLIKELY(!gjs->is_owner_thread())) {
     330                 :           0 :         warn_about_illegal_js_callback("on a different thread",
     331                 :             :                                        "an API not intended to be used in JS",
     332                 :             :                                        false);
     333                 :           0 :         return;
     334                 :             :     }
     335                 :             : 
     336                 :         495 :     JSAutoRealm ar(context, callable());
     337                 :             : 
     338                 :         495 :     int n_args = g_callable_info_get_n_args(m_info);
     339                 :         495 :     g_assert(n_args >= 0);
     340                 :             : 
     341                 :             :     struct AutoCallbackData {
     342                 :         495 :         AutoCallbackData(GjsCallbackTrampoline* trampoline,
     343                 :             :                          GjsContextPrivate* gjs)
     344                 :         495 :             : trampoline(trampoline), gjs(gjs) {}
     345                 :         493 :         ~AutoCallbackData() {
     346         [ +  + ]:         493 :             if (trampoline->m_scope == GI_SCOPE_TYPE_ASYNC) {
     347                 :             :                 // We don't release the trampoline here as we've an extra ref
     348                 :             :                 // that has been set in gjs_marshal_callback_in()
     349                 :             :                 gjs_debug_closure("Saving async closure for gc cleanup %p",
     350                 :             :                                   trampoline);
     351                 :         118 :                 gjs->async_closure_enqueue_for_gc(trampoline);
     352                 :             :             }
     353                 :         493 :             gjs->schedule_gc_if_needed();
     354                 :         493 :         }
     355                 :             : 
     356                 :             :         GjsCallbackTrampoline* trampoline;
     357                 :             :         GjsContextPrivate* gjs;
     358                 :             :     };
     359                 :             : 
     360                 :         495 :     AutoCallbackData callback_data(this, gjs);
     361                 :         495 :     JS::RootedObject this_object(context);
     362                 :         495 :     int c_args_offset = 0;
     363                 :         495 :     GObject* gobj = nullptr;
     364         [ +  + ]:         495 :     if (m_is_vfunc) {
     365                 :         112 :         gobj = G_OBJECT(gjs_arg_get<GObject*>(args[0]));
     366         [ +  - ]:         112 :         if (gobj) {
     367                 :         112 :             this_object = ObjectInstance::wrapper_from_gobject(context, gobj);
     368         [ -  + ]:         112 :             if (!this_object) {
     369         [ #  # ]:           0 :                 if (g_object_get_qdata(gobj, ObjectBase::disposed_quark())) {
     370                 :           0 :                     warn_about_illegal_js_callback(
     371                 :             :                         "on disposed object",
     372                 :             :                         "using the destroy(), dispose(), or remove() vfuncs",
     373                 :             :                         false);
     374                 :             :                 }
     375                 :           0 :                 gjs_log_exception(context);
     376                 :           0 :                 return;
     377                 :             :             }
     378                 :             :         }
     379                 :             : 
     380                 :             :         /* "this" is not included in the GI signature, but is in the C (and
     381                 :             :          * FFI) signature */
     382                 :         112 :         c_args_offset = 1;
     383                 :             :     }
     384                 :             : 
     385                 :         495 :     JS::RootedValue rval(context);
     386                 :             : 
     387         [ +  + ]:         495 :     if (!callback_closure_inner(context, this_object, gobj, &rval, args,
     388                 :             :                                 &ret_type, n_args, c_args_offset, result)) {
     389         [ +  + ]:          25 :         if (!JS_IsExceptionPending(context)) {
     390                 :             :             // "Uncatchable" exception thrown, we have to exit. We may be in a
     391                 :             :             // main loop, or maybe not, but there's no way to tell, so we have
     392                 :             :             // to exit here instead of propagating the exception back to the
     393                 :             :             // original calling JS code.
     394                 :             :             uint8_t code;
     395         [ +  - ]:           1 :             if (gjs->should_exit(&code))
     396                 :           1 :                 gjs->exit_immediately(code);
     397                 :             : 
     398                 :             :             // Some other uncatchable exception, e.g. out of memory
     399                 :           0 :             g_error("Call to %s (%s.%s) terminated with uncatchable exception",
     400                 :             :                     gjs_debug_callable(callable()).c_str(), m_info.ns(),
     401                 :             :                     m_info.name());
     402                 :             :         }
     403                 :             : 
     404                 :             :         // If the callback has a GError** argument, then make a GError from the
     405                 :             :         // value that was thrown. Otherwise, log it as "uncaught" (critical
     406                 :             :         // instead of warning)
     407                 :             : 
     408         [ +  + ]:          24 :         if (!g_callable_info_can_throw_gerror(m_info)) {
     409                 :           8 :             gjs_log_exception_uncaught(context);
     410                 :           8 :             return;
     411                 :             :         }
     412                 :             : 
     413                 :             :         // The GError** pointer is the last argument, and is not included in
     414                 :             :         // the n_args
     415                 :          16 :         GIArgument* error_argument = args[n_args + c_args_offset];
     416                 :          16 :         auto* gerror = gjs_arg_get<GError**>(error_argument);
     417                 :          16 :         GError* local_error = gjs_gerror_make_from_thrown_value(context);
     418                 :          16 :         g_propagate_error(gerror, local_error);
     419                 :             :     }
     420   [ +  +  +  +  :         517 : }
             +  +  +  + ]
     421                 :             : 
     422                 :          35 : inline GIArgument* get_argument_for_arg_info(GIArgInfo* arg_info,
     423                 :             :                                              GIArgument** args, int index) {
     424         [ +  + ]:          35 :     if (!g_arg_info_is_caller_allocates(arg_info))
     425                 :          32 :         return *reinterpret_cast<GIArgument**>(args[index]);
     426                 :             :     else
     427                 :           3 :         return args[index];
     428                 :             : }
     429                 :             : 
     430                 :         495 : bool GjsCallbackTrampoline::callback_closure_inner(
     431                 :             :     JSContext* context, JS::HandleObject this_object, GObject* gobject,
     432                 :             :     JS::MutableHandleValue rval, GIArgument** args, GITypeInfo* ret_type,
     433                 :             :     int n_args, int c_args_offset, void* result) {
     434                 :         495 :     int n_outargs = 0;
     435                 :         495 :     JS::RootedValueVector jsargs(context);
     436                 :             : 
     437         [ -  + ]:         495 :     if (!jsargs.reserve(n_args))
     438                 :           0 :         g_error("Unable to reserve space for vector");
     439                 :             : 
     440                 :         495 :     GITypeTag ret_tag = g_type_info_get_tag(ret_type);
     441                 :         495 :     bool ret_type_is_void = ret_tag == GI_TYPE_TAG_VOID;
     442                 :         495 :     bool in_args_to_cleanup = false;
     443                 :             : 
     444         [ +  + ]:        1818 :     for (int i = 0, n_jsargs = 0; i < n_args; i++) {
     445                 :             :         GIArgInfo arg_info;
     446                 :             :         GITypeInfo type_info;
     447                 :             :         GjsParamType param_type;
     448                 :             : 
     449                 :        1323 :         g_callable_info_load_arg(m_info, i, &arg_info);
     450                 :        1323 :         g_arg_info_load_type(&arg_info, &type_info);
     451                 :             : 
     452                 :             :         /* Skip void * arguments */
     453         [ +  + ]:        1323 :         if (g_type_info_get_tag(&type_info) == GI_TYPE_TAG_VOID)
     454                 :         405 :             continue;
     455                 :             : 
     456         [ +  + ]:         958 :         if (g_arg_info_get_direction(&arg_info) == GI_DIRECTION_OUT) {
     457                 :          34 :             n_outargs++;
     458                 :          34 :             continue;
     459                 :             :         }
     460                 :             : 
     461         [ +  + ]:         924 :         if (g_arg_info_get_direction(&arg_info) == GI_DIRECTION_INOUT)
     462                 :           6 :             n_outargs++;
     463                 :             : 
     464         [ +  + ]:         924 :         if (g_arg_info_get_ownership_transfer(&arg_info) != GI_TRANSFER_NOTHING)
     465                 :           7 :             in_args_to_cleanup = m_scope != GI_SCOPE_TYPE_FOREVER;
     466                 :             : 
     467                 :         924 :         param_type = m_param_types[i];
     468                 :             : 
     469   [ +  +  +  - ]:         924 :         switch (param_type) {
     470                 :           6 :             case PARAM_SKIPPED:
     471                 :           6 :                 continue;
     472                 :           6 :             case PARAM_ARRAY: {
     473                 :           6 :                 gint array_length_pos = g_type_info_get_array_length(&type_info);
     474                 :             :                 GIArgInfo array_length_arg;
     475                 :             :                 GITypeInfo arg_type_info;
     476                 :             : 
     477                 :           6 :                 g_callable_info_load_arg(m_info, array_length_pos,
     478                 :             :                                          &array_length_arg);
     479                 :           6 :                 g_arg_info_load_type(&array_length_arg, &arg_type_info);
     480                 :           6 :                 size_t length = gjs_gi_argument_get_array_length(
     481                 :             :                     g_type_info_get_tag(&arg_type_info),
     482                 :           6 :                     args[array_length_pos + c_args_offset]);
     483                 :             : 
     484         [ -  + ]:           6 :                 if (!jsargs.growBy(1))
     485                 :           0 :                     g_error("Unable to grow vector");
     486                 :             : 
     487         [ -  + ]:           6 :                 if (!gjs_value_from_explicit_array(
     488                 :           6 :                         context, jsargs[n_jsargs++], &type_info,
     489                 :             :                         g_arg_info_get_ownership_transfer(&arg_info),
     490                 :           6 :                         args[i + c_args_offset], length))
     491                 :           0 :                     return false;
     492                 :           6 :                 break;
     493                 :             :             }
     494                 :         912 :             case PARAM_NORMAL: {
     495         [ -  + ]:         912 :                 if (!jsargs.growBy(1))
     496                 :           0 :                     g_error("Unable to grow vector");
     497                 :             : 
     498                 :         912 :                 GIArgument* arg = args[i + c_args_offset];
     499   [ +  +  +  -  :         918 :                 if (g_arg_info_get_direction(&arg_info) == GI_DIRECTION_INOUT &&
                   +  + ]
     500                 :           6 :                     !g_arg_info_is_caller_allocates(&arg_info))
     501                 :           6 :                     arg = *reinterpret_cast<GIArgument**>(arg);
     502                 :             : 
     503         [ -  + ]:         912 :                 if (!gjs_value_from_gi_argument(context, jsargs[n_jsargs++],
     504                 :             :                                                 &type_info, arg, false))
     505                 :           0 :                     return false;
     506                 :         912 :                 break;
     507                 :             :             }
     508                 :           0 :             case PARAM_CALLBACK:
     509                 :             :                 /* Callbacks that accept another callback as a parameter are not
     510                 :             :                  * supported, see gjs_callback_trampoline_new() */
     511                 :             :             case PARAM_UNKNOWN:
     512                 :             :                 // PARAM_UNKNOWN is currently not ever set on a callback's args.
     513                 :             :             default:
     514                 :             :                 g_assert_not_reached();
     515                 :           6 :         }
     516                 :             :     }
     517                 :             : 
     518         [ +  + ]:         495 :     if (!invoke(this_object, jsargs, rval))
     519                 :          17 :         return false;
     520                 :             : 
     521   [ +  +  +  + ]:         477 :     if (n_outargs == 0 && ret_type_is_void) {
     522                 :             :         /* void return value, no out args, nothing to do */
     523         [ +  + ]:         298 :     } else if (n_outargs == 0) {
     524                 :             :         GIArgument argument;
     525                 :             :         GITransfer transfer;
     526                 :             : 
     527                 :         266 :         transfer = g_callable_info_get_caller_owns(m_info);
     528                 :             :         /* non-void return value, no out args. Should
     529                 :             :          * be a single return value. */
     530         [ +  + ]:         266 :         if (!gjs_value_to_gi_argument(context, rval, ret_type, "callback",
     531                 :             :                                       GJS_ARGUMENT_RETURN_VALUE, transfer,
     532                 :             :                                       GjsArgumentFlags::MAY_BE_NULL, &argument))
     533                 :           2 :             return false;
     534                 :             : 
     535                 :         264 :         set_return_ffi_arg_from_gi_argument(ret_type, result, &argument);
     536   [ +  +  +  + ]:          32 :     } else if (n_outargs == 1 && ret_type_is_void) {
     537                 :             :         /* void return value, one out args. Should
     538                 :             :          * be a single return value. */
     539         [ +  - ]:          18 :         for (int i = 0; i < n_args; i++) {
     540                 :             :             GIArgInfo arg_info;
     541                 :          18 :             g_callable_info_load_arg(m_info, i, &arg_info);
     542         [ +  + ]:          18 :             if (g_arg_info_get_direction(&arg_info) == GI_DIRECTION_IN)
     543                 :           2 :                 continue;
     544                 :             : 
     545         [ +  + ]:          16 :             if (!gjs_value_to_callback_out_arg(
     546                 :             :                     context, rval, &arg_info,
     547                 :             :                     get_argument_for_arg_info(&arg_info, args,
     548                 :             :                                               i + c_args_offset)))
     549                 :           3 :                 return false;
     550                 :             : 
     551                 :          13 :             break;
     552                 :             :         }
     553                 :          13 :     } else {
     554                 :          16 :         bool is_array = rval.isObject();
     555         [ -  + ]:          16 :         if (!JS::IsArrayObject(context, rval, &is_array))
     556                 :           3 :             return false;
     557                 :             : 
     558         [ +  + ]:          16 :         if (!is_array) {
     559                 :           6 :             gjs_throw(context,
     560                 :             :                       "Call to %s (%s.%s) returned unexpected value, expecting "
     561                 :             :                       "an Array",
     562                 :           6 :                       gjs_debug_callable(callable()).c_str(), m_info.ns(),
     563                 :             :                       m_info.name());
     564                 :           3 :             return false;
     565                 :             :         }
     566                 :             : 
     567                 :          13 :         JS::RootedValue elem(context);
     568                 :          13 :         JS::RootedObject out_array(context, rval.toObjectOrNull());
     569                 :          13 :         gsize elem_idx = 0;
     570                 :             :         /* more than one of a return value or an out argument.
     571                 :             :          * Should be an array of output values. */
     572                 :             : 
     573         [ +  + ]:          13 :         if (!ret_type_is_void) {
     574                 :             :             GIArgument argument;
     575                 :          10 :             GITransfer transfer = g_callable_info_get_caller_owns(m_info);
     576                 :             : 
     577         [ -  + ]:          10 :             if (!JS_GetElement(context, out_array, elem_idx, &elem))
     578                 :           0 :                 return false;
     579                 :             : 
     580         [ -  + ]:          10 :             if (!gjs_value_to_gi_argument(context, elem, ret_type, "callback",
     581                 :             :                                           GJS_ARGUMENT_RETURN_VALUE, transfer,
     582                 :             :                                           GjsArgumentFlags::MAY_BE_NULL,
     583                 :             :                                           &argument))
     584                 :           0 :                 return false;
     585                 :             : 
     586   [ +  -  +  + ]:          10 :             if ((ret_tag == GI_TYPE_TAG_FILENAME ||
     587         [ +  - ]:           2 :                  ret_tag == GI_TYPE_TAG_UTF8) &&
     588                 :             :                 transfer == GI_TRANSFER_NOTHING) {
     589                 :             :                 // We duplicated the string so not to leak we need to both
     590                 :             :                 // ensure that the string is bound to the object lifetime or
     591                 :             :                 // created once
     592         [ +  - ]:           2 :                 if (gobject) {
     593                 :           2 :                     ObjectInstance::associate_string(
     594                 :             :                         gobject, gjs_arg_get<char*>(&argument));
     595                 :             :                 } else {
     596                 :           0 :                     Gjs::AutoChar str{gjs_arg_steal<char*>(&argument)};
     597                 :           0 :                     gjs_arg_set(&argument, g_intern_string(str));
     598                 :           0 :                 }
     599                 :             :             }
     600                 :             : 
     601                 :          10 :             set_return_ffi_arg_from_gi_argument(ret_type, result, &argument);
     602                 :             : 
     603                 :          10 :             elem_idx++;
     604                 :             :         }
     605                 :             : 
     606         [ +  + ]:          40 :         for (int i = 0; i < n_args; i++) {
     607                 :             :             GIArgInfo arg_info;
     608                 :          27 :             g_callable_info_load_arg(m_info, i, &arg_info);
     609         [ +  + ]:          27 :             if (g_arg_info_get_direction(&arg_info) == GI_DIRECTION_IN)
     610                 :           8 :                 continue;
     611                 :             : 
     612         [ -  + ]:          19 :             if (!JS_GetElement(context, out_array, elem_idx, &elem))
     613                 :           0 :                 return false;
     614                 :             : 
     615         [ -  + ]:          19 :             if (!gjs_value_to_callback_out_arg(
     616                 :             :                     context, elem, &arg_info,
     617                 :             :                     get_argument_for_arg_info(&arg_info, args,
     618                 :             :                                               i + c_args_offset)))
     619                 :           0 :                 return false;
     620                 :             : 
     621                 :          19 :             elem_idx++;
     622                 :             :         }
     623   [ +  -  +  - ]:          13 :     }
     624                 :             : 
     625         [ +  + ]:         469 :     if (!in_args_to_cleanup)
     626                 :         464 :         return true;
     627                 :             : 
     628         [ +  + ]:          12 :     for (int i = 0; i < n_args; i++) {
     629                 :             :         GIArgInfo arg_info;
     630                 :           7 :         g_callable_info_load_arg(m_info, i, &arg_info);
     631                 :           7 :         GITransfer transfer = g_arg_info_get_ownership_transfer(&arg_info);
     632                 :             : 
     633         [ -  + ]:           7 :         if (transfer == GI_TRANSFER_NOTHING)
     634                 :           7 :             continue;
     635                 :             : 
     636         [ +  + ]:           7 :         if (g_arg_info_get_direction(&arg_info) != GI_DIRECTION_IN)
     637                 :           6 :             continue;
     638                 :             : 
     639                 :           1 :         GIArgument* arg = args[i + c_args_offset];
     640         [ +  - ]:           1 :         if (m_scope == GI_SCOPE_TYPE_CALL) {
     641                 :             :             GITypeInfo type_info;
     642                 :           1 :             g_arg_info_load_type(&arg_info, &type_info);
     643                 :             : 
     644         [ -  + ]:           1 :             if (!gjs_gi_argument_release(context, transfer, &type_info, arg))
     645                 :           0 :                 return false;
     646                 :             : 
     647                 :           1 :             continue;
     648                 :           1 :         }
     649                 :             : 
     650                 :             :         struct InvalidateData {
     651                 :             :             GIArgInfo arg_info;
     652                 :             :             GIArgument arg;
     653                 :             :         };
     654                 :             : 
     655                 :           0 :         auto* data = new InvalidateData({arg_info, *arg});
     656                 :           0 :         g_closure_add_invalidate_notifier(
     657                 :           0 :             this, data, [](void* invalidate_data, GClosure* c) {
     658                 :           0 :                 auto* self = static_cast<GjsCallbackTrampoline*>(c);
     659                 :             :                 std::unique_ptr<InvalidateData> data(
     660                 :           0 :                     static_cast<InvalidateData*>(invalidate_data));
     661                 :             :                 GITransfer transfer =
     662                 :           0 :                     g_arg_info_get_ownership_transfer(&data->arg_info);
     663                 :             : 
     664                 :             :                 GITypeInfo type_info;
     665                 :           0 :                 g_arg_info_load_type(&data->arg_info, &type_info);
     666         [ #  # ]:           0 :                 if (!gjs_gi_argument_release(self->context(), transfer,
     667                 :           0 :                                              &type_info, &data->arg)) {
     668                 :           0 :                     gjs_throw(self->context(),
     669                 :             :                               "Impossible to release closure argument '%s'",
     670                 :           0 :                               g_base_info_get_name(&data->arg_info));
     671                 :             :                 }
     672                 :           0 :             });
     673                 :             :     }
     674                 :             : 
     675                 :           5 :     return true;
     676                 :         494 : }
     677                 :             : 
     678                 :         316 : GjsCallbackTrampoline* GjsCallbackTrampoline::create(
     679                 :             :     JSContext* cx, JS::HandleObject callable, GICallableInfo* callable_info,
     680                 :             :     GIScopeType scope, bool has_scope_object, bool is_vfunc) {
     681                 :         316 :     g_assert(JS::IsCallable(callable) &&
     682                 :             :              "tried to create a callback trampoline for a non-callable object");
     683                 :             : 
     684                 :             :     auto* trampoline = new GjsCallbackTrampoline(
     685                 :         316 :         cx, callable, callable_info, scope, has_scope_object, is_vfunc);
     686                 :             : 
     687         [ +  + ]:         316 :     if (!trampoline->initialize()) {
     688                 :           1 :         g_closure_unref(trampoline);
     689                 :           1 :         return nullptr;
     690                 :             :     }
     691                 :             : 
     692                 :         315 :     return trampoline;
     693                 :             : }
     694                 :             : 
     695                 :             : decltype(GjsCallbackTrampoline::s_forever_closure_list)
     696                 :             :     GjsCallbackTrampoline::s_forever_closure_list;
     697                 :             : 
     698                 :         316 : GjsCallbackTrampoline::GjsCallbackTrampoline(
     699                 :             :     JSContext* cx, JS::HandleObject callable, GICallableInfo* callable_info,
     700                 :         316 :     GIScopeType scope, bool has_scope_object, bool is_vfunc)
     701                 :             :     // The rooting rule is:
     702                 :             :     // - notify callbacks in GObject methods are traced from the scope object
     703                 :             :     // - async and call callbacks, and other notify callbacks, are rooted
     704                 :             :     // - vfuncs are traced from the GObject prototype
     705                 :             :     : Closure(cx, callable,
     706   [ +  +  +  + ]:         316 :               scope != GI_SCOPE_TYPE_NOTIFIED || !has_scope_object,
     707                 :             :               g_base_info_get_name(callable_info)),
     708                 :         316 :       m_info(callable_info, Gjs::TakeOwnership{}),
     709                 :         316 :       m_param_types(std::make_unique<GjsParamType[]>(
     710                 :         316 :           g_callable_info_get_n_args(callable_info))),
     711                 :         316 :       m_scope(scope),
     712                 :         948 :       m_is_vfunc(is_vfunc) {
     713                 :         316 :     add_finalize_notifier<GjsCallbackTrampoline>();
     714                 :         316 : }
     715                 :             : 
     716                 :         304 : GjsCallbackTrampoline::~GjsCallbackTrampoline() {
     717   [ +  -  +  +  :         304 :     if (m_info && m_closure)
                   +  + ]
     718                 :         303 :         g_callable_info_destroy_closure(m_info, m_closure);
     719                 :         304 : }
     720                 :             : 
     721                 :           1 : void GjsCallbackTrampoline::mark_forever() {
     722                 :           1 :     s_forever_closure_list.emplace_back(this, Gjs::TakeOwnership{});
     723                 :           1 : }
     724                 :             : 
     725                 :         255 : void GjsCallbackTrampoline::prepare_shutdown() {
     726                 :         255 :     s_forever_closure_list.clear();
     727                 :         255 : }
     728                 :             : 
     729                 :         315 : ffi_closure* GjsCallbackTrampoline::create_closure() {
     730                 :         499 :     auto callback = [](ffi_cif*, void* result, void** ffi_args, void* data) {
     731                 :         499 :         auto** args = reinterpret_cast<GIArgument**>(ffi_args);
     732                 :         499 :         g_assert(data && "Trampoline data is not set");
     733                 :             :         Gjs::Closure::Ptr trampoline{static_cast<GjsCallbackTrampoline*>(data),
     734                 :         499 :                                      Gjs::TakeOwnership{}};
     735                 :             : 
     736                 :         499 :         trampoline.as<GjsCallbackTrampoline>()->callback_closure(args, result);
     737                 :         497 :     };
     738                 :             : 
     739                 :         315 :     return g_callable_info_create_closure(m_info, &m_cif, callback, this);
     740                 :             : }
     741                 :             : 
     742                 :         316 : bool GjsCallbackTrampoline::initialize() {
     743                 :         316 :     g_assert(is_valid());
     744                 :         316 :     g_assert(!m_closure);
     745                 :             : 
     746                 :             :     /* Analyze param types and directions, similarly to
     747                 :             :      * init_cached_function_data */
     748                 :         316 :     int n_param_types = g_callable_info_get_n_args(m_info);
     749         [ +  + ]:         958 :     for (int i = 0; i < n_param_types; i++) {
     750                 :             :         GIDirection direction;
     751                 :             :         GIArgInfo arg_info;
     752                 :             :         GITypeInfo type_info;
     753                 :             :         GITypeTag type_tag;
     754                 :             : 
     755         [ +  + ]:         643 :         if (m_param_types[i] == PARAM_SKIPPED)
     756                 :          45 :             continue;
     757                 :             : 
     758                 :         640 :         g_callable_info_load_arg(m_info, i, &arg_info);
     759                 :         640 :         g_arg_info_load_type(&arg_info, &type_info);
     760                 :             : 
     761                 :         640 :         direction = g_arg_info_get_direction(&arg_info);
     762                 :         640 :         type_tag = g_type_info_get_tag(&type_info);
     763                 :             : 
     764         [ +  + ]:         640 :         if (direction != GI_DIRECTION_IN) {
     765                 :             :             /* INOUT and OUT arguments are handled differently. */
     766                 :          42 :             continue;
     767                 :             :         }
     768                 :             : 
     769         [ +  + ]:         598 :         if (type_tag == GI_TYPE_TAG_INTERFACE) {
     770                 :             :             GI::AutoBaseInfo interface_info{
     771                 :         320 :                 g_type_info_get_interface(&type_info)};
     772                 :         320 :             GIInfoType interface_type = interface_info.type();
     773         [ +  + ]:         320 :             if (interface_type == GI_INFO_TYPE_CALLBACK) {
     774                 :           2 :                 gjs_throw(context(),
     775                 :             :                           "%s %s accepts another callback as a parameter. This "
     776                 :             :                           "is not supported",
     777         [ +  - ]:           1 :                           m_is_vfunc ? "VFunc" : "Callback", m_info.name());
     778                 :           1 :                 return false;
     779                 :             :             }
     780   [ +  +  +  + ]:         598 :         } else if (type_tag == GI_TYPE_TAG_ARRAY) {
     781         [ +  - ]:           3 :             if (g_type_info_get_array_type(&type_info) == GI_ARRAY_TYPE_C) {
     782                 :           3 :                 int array_length_pos = g_type_info_get_array_length(&type_info);
     783                 :             : 
     784         [ -  + ]:           3 :                 if (array_length_pos < 0)
     785                 :           0 :                     continue;
     786                 :             : 
     787         [ +  - ]:           3 :                 if (array_length_pos < n_param_types) {
     788                 :             :                     GIArgInfo length_arg_info;
     789                 :             : 
     790                 :           3 :                     g_callable_info_load_arg(m_info, array_length_pos,
     791                 :             :                                              &length_arg_info);
     792         [ -  + ]:           3 :                     if (g_arg_info_get_direction(&length_arg_info) != direction) {
     793                 :           0 :                         gjs_throw(context(),
     794                 :             :                                   "%s %s has an array with different-direction "
     795                 :             :                                   "length argument. This is not supported",
     796         [ #  # ]:           0 :                                   m_is_vfunc ? "VFunc" : "Callback",
     797                 :             :                                   m_info.name());
     798                 :           0 :                         return false;
     799                 :             :                     }
     800                 :             : 
     801                 :           3 :                     m_param_types[array_length_pos] = PARAM_SKIPPED;
     802                 :           3 :                     m_param_types[i] = PARAM_ARRAY;
     803                 :             :                 }
     804                 :             :             }
     805                 :             :         }
     806                 :             :     }
     807                 :             : 
     808                 :         315 :     m_closure = create_closure();
     809                 :         315 :     return true;
     810                 :             : }
     811                 :             : 
     812                 :             : // Intended for error messages
     813                 :           4 : std::string Gjs::Function::format_name() {
     814                 :           4 :     bool is_method = g_callable_info_is_method(m_info);
     815         [ +  + ]:           4 :     std::string retval = is_method ? "method" : "function";
     816                 :           4 :     retval += ' ';
     817                 :           4 :     retval += m_info.ns();
     818                 :           4 :     retval += '.';
     819         [ +  + ]:           4 :     if (is_method) {
     820                 :           1 :         retval += g_base_info_get_name(g_base_info_get_container(m_info));
     821                 :           1 :         retval += '.';
     822                 :             :     }
     823                 :           4 :     retval += m_info.name();
     824                 :           4 :     return retval;
     825                 :             : }
     826                 :             : 
     827                 :             : namespace Gjs {
     828                 :             : 
     829                 :       73363 : static void* get_return_ffi_pointer_from_gi_argument(
     830                 :             :     Maybe<Arg::ReturnTag> return_tag, GIFFIReturnValue* return_value) {
     831         [ +  + ]:       73363 :     if (!return_tag)
     832                 :       33800 :         return nullptr;
     833         [ +  + ]:       39563 :     if (return_tag->is_pointer())
     834                 :       19460 :         return &gjs_arg_member<void*>(return_value);
     835   [ -  +  +  +  :       20103 :     switch (return_tag->tag()) {
          +  +  +  +  +  
          +  +  +  +  +  
                      + ]
     836                 :           0 :         case GI_TYPE_TAG_VOID:
     837                 :             :             g_assert_not_reached();
     838                 :          18 :         case GI_TYPE_TAG_INT8:
     839                 :          18 :             return &gjs_arg_member<int8_t>(return_value);
     840                 :          20 :         case GI_TYPE_TAG_INT16:
     841                 :          20 :             return &gjs_arg_member<int16_t>(return_value);
     842                 :         165 :         case GI_TYPE_TAG_INT32:
     843                 :         165 :             return &gjs_arg_member<int32_t>(return_value);
     844                 :          23 :         case GI_TYPE_TAG_UINT8:
     845                 :          23 :             return &gjs_arg_member<uint8_t>(return_value);
     846                 :          13 :         case GI_TYPE_TAG_UINT16:
     847                 :          13 :             return &gjs_arg_member<uint16_t>(return_value);
     848                 :       13591 :         case GI_TYPE_TAG_UINT32:
     849                 :       13591 :             return &gjs_arg_member<uint32_t>(return_value);
     850                 :        1147 :         case GI_TYPE_TAG_BOOLEAN:
     851                 :        1147 :             return &gjs_arg_member<Gjs::Tag::GBoolean>(return_value);
     852                 :           3 :         case GI_TYPE_TAG_UNICHAR:
     853                 :           3 :             return &gjs_arg_member<uint32_t>(return_value);
     854                 :          78 :         case GI_TYPE_TAG_INT64:
     855                 :          78 :             return &gjs_arg_member<int64_t>(return_value);
     856                 :         617 :         case GI_TYPE_TAG_UINT64:
     857                 :         617 :             return &gjs_arg_member<uint64_t>(return_value);
     858                 :          13 :         case GI_TYPE_TAG_FLOAT:
     859                 :          13 :             return &gjs_arg_member<float>(return_value);
     860                 :          24 :         case GI_TYPE_TAG_DOUBLE:
     861                 :          24 :             return &gjs_arg_member<double>(return_value);
     862                 :        2100 :         case GI_TYPE_TAG_INTERFACE: {
     863         [ +  - ]:        2100 :             if (return_tag->is_enum_or_flags_interface())
     864                 :        2100 :                 return &gjs_arg_member<Gjs::Tag::UnsignedEnum>(return_value);
     865                 :             :             [[fallthrough]];
     866                 :             :         }
     867                 :             :         default:
     868                 :        2291 :             return &gjs_arg_member<void*>(return_value);
     869                 :             :     }
     870                 :             : }
     871                 :             : 
     872                 :             : // This function can be called in two different ways. You can either use it to
     873                 :             : // create JavaScript objects by calling it without @r_value, or you can decide
     874                 :             : // to keep the return values in GIArgument format by providing a @r_value
     875                 :             : // argument.
     876                 :       73430 : bool Function::invoke(JSContext* context, const JS::CallArgs& args,
     877                 :             :                       JS::HandleObject this_obj /* = nullptr */,
     878                 :             :                       GIArgument* r_value /* = nullptr */) {
     879                 :       73430 :     g_assert((args.isConstructing() || !this_obj) &&
     880                 :             :              "If not a constructor, then pass the 'this' object via CallArgs");
     881                 :             : 
     882                 :             :     GIFFIReturnValue return_value;
     883                 :             : 
     884                 :       73430 :     unsigned ffi_argc = m_invoker.cif.nargs;
     885                 :       73430 :     GjsFunctionCallState state(context, m_info);
     886                 :             : 
     887         [ -  + ]:       73430 :     if (state.gi_argc > Argument::MAX_ARGS) {
     888                 :           0 :         gjs_throw(context, "Function %s has too many arguments",
     889                 :           0 :                   format_name().c_str());
     890                 :           0 :         return false;
     891                 :             :     }
     892                 :             : 
     893                 :             :     // ffi_argc is the number of arguments that the underlying C function takes.
     894                 :             :     // state.gi_argc is the number of arguments the GICallableInfo describes
     895                 :             :     // (which does not include "this" or GError**). m_js_in_argc is the number
     896                 :             :     // of arguments we expect the JS function to take (which does not include
     897                 :             :     // PARAM_SKIPPED args).
     898                 :             :     // args.length() is the number of arguments that were actually passed.
     899         [ +  + ]:       73430 :     if (args.length() > m_js_in_argc) {
     900                 :           2 :         if (!JS::WarnUTF8(context,
     901                 :             :                           "Too many arguments to %s: expected %u, got %u",
     902         [ -  + ]:           2 :                           format_name().c_str(), m_js_in_argc, args.length()))
     903                 :           0 :             return false;
     904         [ +  + ]:       73429 :     } else if (args.length() < m_js_in_argc) {
     905                 :           3 :         args.reportMoreArgsNeeded(context, format_name().c_str(), m_js_in_argc,
     906                 :             :                                   args.length());
     907                 :           3 :         return false;
     908                 :             :     }
     909                 :             : 
     910                 :             :     // These arrays hold argument pointers.
     911                 :             :     // - state.in_cvalue(): C values which are passed on input (in or inout)
     912                 :             :     // - state.out_cvalue(): C values which are returned as arguments (out or
     913                 :             :     //   inout)
     914                 :             :     // - state.inout_original_cvalue(): For the special case of (inout) args,
     915                 :             :     //   we need to keep track of the original values we passed into the
     916                 :             :     //   function, in case we need to free it.
     917                 :             :     // - ffi_arg_pointers: For passing data to FFI, we need to create another
     918                 :             :     //   layer of indirection; this array is a pointer to an element in
     919                 :             :     //   state.in_cvalue() or state.out_cvalue().
     920                 :             :     // - return_value: The actual return value of the C function, i.e. not an
     921                 :             :     //   (out) param
     922                 :             :     //
     923                 :             :     // The 3 GIArgument arrays are indexed by the GI argument index.
     924                 :             :     // ffi_arg_pointers, on the other hand, represents the actual C arguments,
     925                 :             :     // in the way ffi expects them.
     926                 :             : 
     927                 :       73427 :     auto ffi_arg_pointers = std::make_unique<void*[]>(ffi_argc);
     928                 :             : 
     929                 :       73427 :     int gi_arg_pos = 0;        // index into GIArgument array
     930                 :       73427 :     unsigned ffi_arg_pos = 0;  // index into ffi_arg_pointers
     931                 :       73427 :     unsigned js_arg_pos = 0;   // index into args
     932                 :             : 
     933                 :       73427 :     JS::RootedObject obj(context, this_obj);
     934   [ +  +  -  +  :       73427 :     if (!args.isConstructing() && !args.computeThis(context, &obj))
                   -  + ]
     935                 :           0 :         return false;
     936                 :             : 
     937                 :       73427 :     std::string dynamicString("(unknown)");
     938                 :             : 
     939         [ +  + ]:       73427 :     if (state.is_method) {
     940                 :       40057 :         GIArgument* in_value = state.instance();
     941                 :       40057 :         JS::RootedValue in_js_value(context, JS::ObjectValue(*obj));
     942                 :             : 
     943         [ +  + ]:       40057 :         if (!m_arguments.instance().value()->in(context, &state, in_value,
     944                 :             :                                                 in_js_value))
     945                 :           4 :             return false;
     946                 :             : 
     947                 :       40053 :         ffi_arg_pointers[ffi_arg_pos] = in_value;
     948                 :       40053 :         ++ffi_arg_pos;
     949                 :             : 
     950                 :             :         // Callback lifetimes will be attached to the instance object if it is
     951                 :             :         // a GObject or GInterface
     952                 :       40053 :         Maybe<GType> gtype = m_arguments.instance_type();
     953         [ +  - ]:       40053 :         if (gtype) {
     954   [ +  +  +  +  :       78603 :             if (g_type_is_a(*gtype, G_TYPE_OBJECT) ||
                   +  + ]
     955   [ +  -  +  + ]:       38550 :                 g_type_is_a(*gtype, G_TYPE_INTERFACE))
     956                 :        1506 :                 state.instance_object = obj;
     957                 :             : 
     958   [ +  +  +  +  :       40053 :             if (g_type_is_a(*gtype, G_TYPE_OBJECT)) {
                   +  + ]
     959                 :        1503 :                 auto* o = ObjectBase::for_js(context, obj);
     960                 :             :                 dynamicString =
     961   [ -  +  +  - ]:        4509 :                     GJS_PROFILER_DYNAMIC_STRING(context, o->format_name());
     962                 :             :             }
     963                 :             :         }
     964         [ +  + ]:       40057 :     }
     965   [ +  -  -  +  :      220269 :     std::string full_name{GJS_PROFILER_DYNAMIC_STRING(
                   -  + ]
     966         [ -  + ]:      146846 :         context, dynamicString + "." + format_name())};
     967                 :       73423 :     AutoProfilerLabel label{context, "", full_name};
     968                 :             : 
     969                 :       73423 :     g_assert(ffi_arg_pos + state.gi_argc <
     970                 :             :              std::numeric_limits<decltype(state.processed_c_args)>::max());
     971                 :             : 
     972                 :       73423 :     state.processed_c_args = ffi_arg_pos;
     973         [ +  + ]:      155295 :     for (gi_arg_pos = 0; gi_arg_pos < state.gi_argc;
     974                 :       81872 :          gi_arg_pos++, ffi_arg_pos++) {
     975                 :       81932 :         GIArgument* in_value = &state.in_cvalue(gi_arg_pos);
     976                 :       81932 :         Argument* gjs_arg = m_arguments.argument(gi_arg_pos);
     977                 :             : 
     978                 :             :         gjs_debug_marshal(GJS_DEBUG_GFUNCTION,
     979                 :             :                           "Marshalling argument '%s' in, %d/%d GI args, %u/%u "
     980                 :             :                           "C args, %u/%u JS args",
     981                 :             :                           gjs_arg ? gjs_arg->arg_name() : "<unknown>",
     982                 :             :                           gi_arg_pos, state.gi_argc, ffi_arg_pos, ffi_argc,
     983                 :             :                           js_arg_pos, args.length());
     984                 :             : 
     985                 :       81932 :         ffi_arg_pointers[ffi_arg_pos] = in_value;
     986                 :             : 
     987         [ -  + ]:       81932 :         if (!gjs_arg) {
     988                 :             :             GIArgInfo arg_info;
     989                 :           0 :             g_callable_info_load_arg(m_info, gi_arg_pos, &arg_info);
     990                 :           0 :             gjs_throw(context,
     991                 :             :                       "Error invoking %s: impossible to determine what to pass "
     992                 :             :                       "to the '%s' argument. It may be that the function is "
     993                 :             :                       "unsupported, or there may be a bug in its annotations.",
     994                 :           0 :                       format_name().c_str(), g_base_info_get_name(&arg_info));
     995                 :           0 :             state.failed = true;
     996                 :           0 :             break;
     997                 :             :         }
     998                 :             : 
     999                 :       81932 :         JS::RootedValue js_in_arg(context);
    1000         [ +  + ]:       81932 :         if (js_arg_pos < args.length())
    1001                 :       80555 :             js_in_arg = args[js_arg_pos];
    1002                 :             : 
    1003         [ +  + ]:       81932 :         if (!gjs_arg->in(context, &state, in_value, js_in_arg)) {
    1004                 :          60 :             state.failed = true;
    1005                 :          60 :             break;
    1006                 :             :         }
    1007                 :             : 
    1008         [ +  + ]:       81872 :         if (!gjs_arg->skip_in())
    1009                 :       80353 :             js_arg_pos++;
    1010                 :             : 
    1011                 :       81872 :         state.processed_c_args++;
    1012         [ +  + ]:       81932 :     }
    1013                 :             : 
    1014                 :             :     // This pointer needs to exist on the stack across the ffi_call() call
    1015                 :       73423 :     GError** errorp = &state.local_error;
    1016                 :             : 
    1017                 :             :     /* Did argument conversion fail?  In that case, skip invocation and jump to release
    1018                 :             :      * processing. */
    1019         [ +  + ]:       73423 :     if (state.failed)
    1020                 :          60 :         return finish_invoke(context, args, &state, r_value);
    1021                 :             : 
    1022         [ +  + ]:       73363 :     if (state.can_throw_gerror) {
    1023                 :         346 :         g_assert(ffi_arg_pos < ffi_argc && "GError** argument number mismatch");
    1024                 :         346 :         ffi_arg_pointers[ffi_arg_pos] = &errorp;
    1025                 :         346 :         ffi_arg_pos++;
    1026                 :             : 
    1027                 :             :         /* don't update state.processed_c_args as we deal with local_error
    1028                 :             :          * separately */
    1029                 :             :     }
    1030                 :             : 
    1031                 :       73363 :     g_assert_cmpuint(ffi_arg_pos, ==, ffi_argc);
    1032                 :       73363 :     g_assert_cmpuint(gi_arg_pos, ==, state.gi_argc);
    1033                 :             : 
    1034                 :       73363 :     Maybe<Arg::ReturnTag> return_tag = m_arguments.return_tag();
    1035                 :             :     // return_value_p will point inside the return GIFFIReturnValue union if the
    1036                 :             :     // C function has a non-void return type
    1037                 :             :     void* return_value_p =
    1038                 :       73363 :         get_return_ffi_pointer_from_gi_argument(return_tag, &return_value);
    1039                 :       73363 :     ffi_call(&m_invoker.cif, FFI_FN(m_invoker.native_address), return_value_p,
    1040                 :             :              ffi_arg_pointers.get());
    1041                 :             : 
    1042                 :             :     /* Return value and out arguments are valid only if invocation doesn't
    1043                 :             :      * return error. In arguments need to be released always.
    1044                 :             :      */
    1045         [ +  + ]:       73361 :     if (!r_value)
    1046                 :       73340 :         args.rval().setUndefined();
    1047                 :             : 
    1048         [ +  + ]:       73361 :     if (return_tag) {
    1049                 :       39563 :         gi_type_tag_extract_ffi_return_value(
    1050                 :             :             return_tag->tag(), return_tag->interface_type(), &return_value,
    1051                 :             :             state.return_value());
    1052                 :             :     }
    1053                 :             : 
    1054                 :             :     // Process out arguments and return values. This loop is skipped if we fail
    1055                 :             :     // the type conversion above, or if state.did_throw_gerror is true.
    1056                 :       73361 :     js_arg_pos = 0;
    1057         [ +  + ]:      228586 :     for (gi_arg_pos = -1; gi_arg_pos < state.gi_argc; gi_arg_pos++) {
    1058                 :      155225 :         Maybe<Argument*> gjs_arg;
    1059                 :             :         GIArgument* out_value;
    1060                 :             : 
    1061         [ +  + ]:      155225 :         if (gi_arg_pos == -1) {
    1062                 :       73361 :             out_value = state.return_value();
    1063                 :       73361 :             gjs_arg = m_arguments.return_value();
    1064                 :             :         } else {
    1065                 :       81864 :             out_value = &state.out_cvalue(gi_arg_pos);
    1066                 :       81864 :             gjs_arg = Some(m_arguments.argument(gi_arg_pos));
    1067                 :             :         }
    1068                 :             : 
    1069                 :             :         gjs_debug_marshal(
    1070                 :             :             GJS_DEBUG_GFUNCTION, "Marshalling argument '%s' out, %d/%d GI args",
    1071                 :             :             gjs_arg.map(std::mem_fn(&Argument::arg_name)).valueOr("<unknown>"),
    1072                 :             :             gi_arg_pos, state.gi_argc);
    1073                 :             : 
    1074                 :      155225 :         JS::RootedValue js_out_arg(context);
    1075         [ +  + ]:      155225 :         if (!r_value) {
    1076   [ +  +  -  +  :      155184 :             if (!gjs_arg && gi_arg_pos >= 0) {
                   -  + ]
    1077                 :             :                 GIArgInfo arg_info;
    1078                 :           0 :                 g_callable_info_load_arg(m_info, gi_arg_pos, &arg_info);
    1079                 :           0 :                 gjs_throw(
    1080                 :             :                     context,
    1081                 :             :                     "Error invoking %s: impossible to determine what to pass "
    1082                 :             :                     "to the out '%s' argument. It may be that the function is "
    1083                 :             :                     "unsupported, or there may be a bug in its annotations.",
    1084                 :           0 :                     format_name().c_str(), g_base_info_get_name(&arg_info));
    1085                 :           0 :                 state.failed = true;
    1086                 :           0 :                 break;
    1087                 :             :             }
    1088                 :             : 
    1089         [ +  + ]:      276570 :             if (gjs_arg &&
    1090   [ -  +  -  + ]:      431754 :                 !(*gjs_arg)->out(context, &state, out_value, &js_out_arg)) {
    1091                 :           0 :                 state.failed = true;
    1092                 :           0 :                 break;
    1093                 :             :             }
    1094                 :             :         }
    1095                 :             : 
    1096   [ +  +  +  +  :      155225 :         if (gjs_arg && !(*gjs_arg)->skip_out()) {
                   +  + ]
    1097         [ +  + ]:       40431 :             if (!r_value) {
    1098         [ -  + ]:       40410 :                 if (!state.return_values.append(js_out_arg)) {
    1099                 :           0 :                     JS_ReportOutOfMemory(context);
    1100                 :           0 :                     state.failed = true;
    1101                 :           0 :                     break;
    1102                 :             :                 }
    1103                 :             :             }
    1104                 :       40431 :             js_arg_pos++;
    1105                 :             :         }
    1106         [ +  - ]:      155225 :     }
    1107                 :             : 
    1108                 :       73361 :     g_assert(state.failed || state.did_throw_gerror() ||
    1109                 :             :              js_arg_pos == m_js_out_argc);
    1110                 :             : 
    1111                 :             :     // If we failed before calling the function, or if the function threw an
    1112                 :             :     // exception, then any GI_TRANSFER_EVERYTHING or GI_TRANSFER_CONTAINER
    1113                 :             :     // in-parameters were not transferred. Treat them as GI_TRANSFER_NOTHING so
    1114                 :             :     // that they are freed.
    1115                 :       73361 :     return finish_invoke(context, args, &state, r_value);
    1116                 :       73428 : }
    1117                 :             : 
    1118                 :       73421 : bool Function::finish_invoke(JSContext* cx, const JS::CallArgs& args,
    1119                 :             :                              GjsFunctionCallState* state,
    1120                 :             :                              GIArgument* r_value /* = nullptr */) {
    1121                 :             :     // In this loop we use ffi_arg_pos just to ensure we don't release stuff
    1122                 :             :     // we haven't allocated yet, if we failed in type conversion above.
    1123                 :             :     // If we start from -1 (the return value), we need to process 1 more than
    1124                 :             :     // state.processed_c_args.
    1125                 :             :     // If we start from -2 (the instance parameter), we need to process 2 more
    1126                 :       73421 :     unsigned ffi_arg_pos = state->first_arg_offset() - 1;
    1127                 :       73421 :     unsigned ffi_arg_max = state->last_processed_index();
    1128                 :       73421 :     bool postinvoke_release_failed = false;
    1129                 :       73421 :     for (int gi_arg_pos = -(state->first_arg_offset());
    1130   [ +  +  +  + ]:      268765 :          gi_arg_pos < state->gi_argc && ffi_arg_pos < ffi_arg_max;
    1131                 :      195344 :          gi_arg_pos++, ffi_arg_pos++) {
    1132                 :      195344 :         Maybe<Argument*> gjs_arg;
    1133                 :      195344 :         GIArgument* in_value = nullptr;
    1134                 :      195344 :         GIArgument* out_value = nullptr;
    1135                 :             : 
    1136         [ +  + ]:      195344 :         if (gi_arg_pos == -2) {
    1137                 :       40051 :             in_value = state->instance();
    1138                 :       40051 :             gjs_arg = m_arguments.instance();
    1139         [ +  + ]:      155293 :         } else if (gi_arg_pos == -1) {
    1140                 :       73421 :             out_value = state->return_value();
    1141                 :       73421 :             gjs_arg = m_arguments.return_value();
    1142                 :             :         } else {
    1143                 :       81872 :             in_value = &state->in_cvalue(gi_arg_pos);
    1144                 :       81872 :             out_value = &state->out_cvalue(gi_arg_pos);
    1145                 :       81872 :             gjs_arg = Some(m_arguments.argument(gi_arg_pos));
    1146                 :             :         }
    1147                 :             : 
    1148         [ +  + ]:      195344 :         if (!gjs_arg)
    1149                 :       33884 :             continue;
    1150                 :             : 
    1151                 :             :         gjs_debug_marshal(
    1152                 :             :             GJS_DEBUG_GFUNCTION,
    1153                 :             :             "Releasing argument '%s', %d/%d GI args, %u/%u C args",
    1154                 :             :             (*gjs_arg)->arg_name(), gi_arg_pos, state->gi_argc, ffi_arg_pos,
    1155                 :             :             state->processed_c_args);
    1156                 :             : 
    1157                 :             :         // Only process in or inout arguments if we failed, the rest is garbage
    1158   [ +  +  +  +  :      161539 :         if (state->failed && (*gjs_arg)->skip_in())
                   +  + ]
    1159                 :          58 :             continue;
    1160                 :             : 
    1161                 :             :         // Save the return GIArgument if it was requested
    1162   [ +  +  +  + ]:      161481 :         if (r_value && gi_arg_pos == -1) {
    1163                 :          21 :             *r_value = *out_value;
    1164                 :          21 :             continue;
    1165                 :             :         }
    1166                 :             : 
    1167         [ -  + ]:      161460 :         if (!(*gjs_arg)->release(cx, state, in_value, out_value)) {
    1168                 :           0 :             postinvoke_release_failed = true;
    1169                 :             :             // continue with the release even if we fail, to avoid leaks
    1170                 :             :         }
    1171                 :             :     }
    1172                 :             : 
    1173         [ -  + ]:       73421 :     if (postinvoke_release_failed)
    1174                 :           0 :         state->failed = true;
    1175                 :             : 
    1176                 :       73421 :     g_assert(ffi_arg_pos == state->last_processed_index());
    1177                 :             : 
    1178   [ +  +  +  +  :       73421 :     if (!r_value && m_js_out_argc > 0 && state->call_completed()) {
             +  +  +  + ]
    1179                 :             :         // If we have one return value or out arg, return that item on its
    1180                 :             :         // own, otherwise return a JavaScript array with [return value,
    1181                 :             :         // out arg 1, out arg 2, ...]
    1182         [ +  + ]:       39736 :         if (m_js_out_argc == 1) {
    1183                 :       39144 :             args.rval().set(state->return_values[0]);
    1184                 :             :         } else {
    1185                 :         592 :             JSObject* array = JS::NewArrayObject(cx, state->return_values);
    1186         [ -  + ]:         592 :             if (!array) {
    1187                 :           0 :                 state->failed = true;
    1188                 :             :             } else {
    1189                 :         592 :                 args.rval().setObject(*array);
    1190                 :             :             }
    1191                 :             :         }
    1192                 :             :     }
    1193                 :             : 
    1194   [ +  +  +  +  :       73421 :     if (!state->failed && state->did_throw_gerror()) {
                   +  + ]
    1195                 :          41 :         return gjs_throw_gerror(cx, state->local_error.release());
    1196         [ +  + ]:       73380 :     } else if (state->failed) {
    1197                 :          60 :         return false;
    1198                 :             :     } else {
    1199                 :       73320 :         return true;
    1200                 :             :     }
    1201                 :             : }
    1202                 :             : 
    1203                 :       73409 : bool Function::call(JSContext* context, unsigned js_argc, JS::Value* vp) {
    1204                 :       73409 :     JS::CallArgs js_argv = JS::CallArgsFromVp(js_argc, vp);
    1205                 :       73409 :     JS::RootedObject callee(context, &js_argv.callee());
    1206                 :             : 
    1207                 :             :     Function* priv;
    1208         [ -  + ]:       73409 :     if (!Function::for_js_typecheck(context, callee, &priv, &js_argv))
    1209                 :           0 :         return false;
    1210                 :             : 
    1211                 :             :     gjs_debug_marshal(GJS_DEBUG_GFUNCTION, "Call callee %p priv %p",
    1212                 :             :                       callee.get(), priv);
    1213                 :             : 
    1214                 :       73409 :     g_assert(priv);
    1215                 :       73409 :     return priv->invoke(context, js_argv);
    1216                 :       73407 : }
    1217                 :             : 
    1218                 :       11747 : Function::~Function() {
    1219                 :       11747 :     g_function_invoker_destroy(&m_invoker);
    1220                 :       11747 :     GJS_DEC_COUNTER(function);
    1221                 :       11747 : }
    1222                 :             : 
    1223                 :       11726 : void Function::finalize_impl(JS::GCContext*, Function* priv) {
    1224                 :       11726 :     g_assert(priv);
    1225         [ +  - ]:       11726 :     delete priv;
    1226                 :       11726 : }
    1227                 :             : 
    1228                 :          20 : bool Function::get_length(JSContext* cx, unsigned argc, JS::Value* vp) {
    1229         [ -  + ]:          20 :     GJS_GET_THIS(cx, argc, vp, args, this_obj);
    1230                 :             :     Function* priv;
    1231         [ -  + ]:          20 :     if (!Function::for_js_instance(cx, this_obj, &priv, &args))
    1232                 :           0 :         return false;
    1233                 :          20 :     args.rval().setInt32(priv->m_js_in_argc);
    1234                 :          20 :     return true;
    1235                 :          20 : }
    1236                 :             : 
    1237                 :           0 : bool Function::to_string(JSContext* context, unsigned argc, JS::Value* vp) {
    1238   [ #  #  #  # ]:           0 :     GJS_CHECK_WRAPPER_PRIV(context, argc, vp, rec, this_obj, Function, priv);
    1239                 :           0 :     return priv->to_string_impl(context, rec.rval());
    1240                 :           0 : }
    1241                 :             : 
    1242                 :           0 : bool Function::to_string_impl(JSContext* cx, JS::MutableHandleValue rval) {
    1243                 :             :     int i, n_jsargs;
    1244                 :             : 
    1245                 :           0 :     int n_args = g_callable_info_get_n_args(m_info);
    1246                 :           0 :     n_jsargs = 0;
    1247                 :           0 :     std::string arg_names;
    1248         [ #  # ]:           0 :     for (i = 0; i < n_args; i++) {
    1249                 :           0 :         Argument* gjs_arg = m_arguments.argument(i);
    1250   [ #  #  #  #  :           0 :         if (!gjs_arg || gjs_arg->skip_in())
                   #  # ]
    1251                 :           0 :             continue;
    1252                 :             : 
    1253         [ #  # ]:           0 :         if (n_jsargs > 0)
    1254                 :           0 :             arg_names += ", ";
    1255                 :             : 
    1256                 :           0 :         n_jsargs++;
    1257                 :           0 :         arg_names += gjs_arg->arg_name();
    1258                 :             :     }
    1259                 :             : 
    1260                 :           0 :     AutoChar descr;
    1261         [ #  # ]:           0 :     if (GI_IS_FUNCTION_INFO(m_info)) {
    1262                 :             :         descr = g_strdup_printf(
    1263                 :             :             "%s(%s) {\n\t/* wrapper for native symbol %s() */\n}",
    1264                 :           0 :             format_name().c_str(), arg_names.c_str(),
    1265                 :           0 :             g_function_info_get_symbol(m_info));
    1266                 :             :     } else {
    1267                 :             :         descr =
    1268                 :             :             g_strdup_printf("%s(%s) {\n\t/* wrapper for native symbol */\n}",
    1269                 :           0 :                             format_name().c_str(), arg_names.c_str());
    1270                 :             :     }
    1271                 :             : 
    1272                 :           0 :     return gjs_string_from_utf8(cx, descr, rval);
    1273                 :           0 : }
    1274                 :             : 
    1275                 :             : const JSClassOps Function::class_ops = {
    1276                 :             :     nullptr,  // addProperty
    1277                 :             :     nullptr,  // deleteProperty
    1278                 :             :     nullptr,  // enumerate
    1279                 :             :     nullptr,  // newEnumerate
    1280                 :             :     nullptr,  // resolve
    1281                 :             :     nullptr,  // mayResolve
    1282                 :             :     &Function::finalize,
    1283                 :             :     &Function::call,
    1284                 :             : };
    1285                 :             : 
    1286                 :             : const JSPropertySpec Function::proto_props[] = {
    1287                 :             :     JS_PSG("length", &Function::get_length, JSPROP_PERMANENT),
    1288                 :             :     JS_STRING_SYM_PS(toStringTag, "GIRepositoryFunction", JSPROP_READONLY),
    1289                 :             :     JS_PS_END};
    1290                 :             : 
    1291                 :             : /* The original Function.prototype.toString complains when
    1292                 :             :    given a GIRepository function as an argument */
    1293                 :             : // clang-format off
    1294                 :             : const JSFunctionSpec Function::proto_funcs[] = {
    1295                 :             :     JS_FN("toString", &Function::to_string, 0, 0),
    1296                 :             :     JS_FS_END};
    1297                 :             : // clang-format on
    1298                 :             : 
    1299                 :       11926 : bool Function::init(JSContext* context, GType gtype /* = G_TYPE_NONE */) {
    1300                 :             :     guint8 i;
    1301                 :       11926 :     AutoError error;
    1302                 :             : 
    1303         [ +  + ]:       11926 :     if (GI_IS_FUNCTION_INFO(m_info)) {
    1304         [ -  + ]:       11924 :         if (!g_function_info_prep_invoker(m_info, &m_invoker, &error))
    1305                 :           0 :             return gjs_throw_gerror(context, error);
    1306         [ +  - ]:           2 :     } else if (GI_IS_VFUNC_INFO(m_info)) {
    1307                 :           2 :         void* addr = g_vfunc_info_get_address(m_info, gtype, &error);
    1308         [ -  + ]:           2 :         if (error) {
    1309         [ #  # ]:           0 :             if (error->code != G_INVOKE_ERROR_SYMBOL_NOT_FOUND)
    1310                 :           0 :                 return gjs_throw_gerror(context, error);
    1311                 :             : 
    1312                 :           0 :             gjs_throw(context, "Virtual function not implemented: %s",
    1313                 :           0 :                       error->message);
    1314                 :           0 :             return false;
    1315                 :             :         }
    1316                 :             : 
    1317         [ -  + ]:           2 :         if (!g_function_invoker_new_for_address(addr, m_info, &m_invoker,
    1318                 :             :                                                 &error))
    1319                 :           0 :             return gjs_throw_gerror(context, error);
    1320                 :             :     }
    1321                 :             : 
    1322                 :       11926 :     uint8_t n_args = g_callable_info_get_n_args(m_info);
    1323                 :             : 
    1324         [ -  + ]:       11926 :     if (!m_arguments.initialize(context, m_info))
    1325                 :           0 :         return false;
    1326                 :             : 
    1327                 :       11926 :     m_arguments.build_instance(m_info);
    1328                 :             : 
    1329                 :             :     bool inc_counter;
    1330                 :       11926 :     m_arguments.build_return(m_info, &inc_counter);
    1331                 :             : 
    1332         [ +  + ]:       11926 :     if (inc_counter)
    1333                 :        9370 :         m_js_out_argc++;
    1334                 :             : 
    1335         [ +  + ]:       34672 :     for (i = 0; i < n_args; i++) {
    1336                 :       22746 :         Argument* gjs_arg = m_arguments.argument(i);
    1337                 :             :         GIDirection direction;
    1338                 :             :         GIArgInfo arg_info;
    1339                 :             : 
    1340   [ +  +  -  +  :       22746 :         if (gjs_arg && (gjs_arg->skip_in() || gjs_arg->skip_out())) {
             -  -  +  + ]
    1341                 :        1742 :             continue;
    1342                 :             :         }
    1343                 :             : 
    1344                 :       21004 :         g_callable_info_load_arg(m_info, i, &arg_info);
    1345                 :       21004 :         direction = g_arg_info_get_direction(&arg_info);
    1346                 :             : 
    1347                 :       21004 :         m_arguments.build_arg(i, direction, &arg_info, m_info, &inc_counter);
    1348                 :             : 
    1349         [ +  + ]:       21004 :         if (inc_counter) {
    1350   [ +  +  +  - ]:       20759 :             switch (direction) {
    1351                 :          98 :                 case GI_DIRECTION_INOUT:
    1352                 :          98 :                     m_js_out_argc++;
    1353                 :             :                     [[fallthrough]];
    1354                 :       19943 :                 case GI_DIRECTION_IN:
    1355                 :       19943 :                     m_js_in_argc++;
    1356                 :       19943 :                     break;
    1357                 :         816 :                 case GI_DIRECTION_OUT:
    1358                 :         816 :                     m_js_out_argc++;
    1359                 :         816 :                     break;
    1360                 :           0 :                 default:
    1361                 :             :                     g_assert_not_reached();
    1362                 :             :             }
    1363                 :             :         }
    1364                 :             :     }
    1365                 :             : 
    1366                 :       11926 :     return true;
    1367                 :       11926 : }
    1368                 :             : 
    1369                 :       11905 : JSObject* Function::create(JSContext* context, GType gtype,
    1370                 :             :                            GICallableInfo* info) {
    1371                 :       11905 :     JS::RootedObject proto(context, Function::create_prototype(context));
    1372         [ -  + ]:       11905 :     if (!proto)
    1373                 :           0 :         return nullptr;
    1374                 :             : 
    1375                 :             :     JS::RootedObject function(
    1376                 :       11905 :         context, JS_NewObjectWithGivenProto(context, &Function::klass, proto));
    1377         [ -  + ]:       11905 :     if (!function) {
    1378                 :           0 :         gjs_debug(GJS_DEBUG_GFUNCTION, "Failed to construct function");
    1379                 :           0 :         return NULL;
    1380                 :             :     }
    1381                 :             : 
    1382                 :       11905 :     auto* priv = new Function(info);
    1383                 :             : 
    1384                 :       11905 :     Function::init_private(function, priv);
    1385                 :             : 
    1386                 :       11905 :     debug_lifecycle(function, priv, "Constructor");
    1387                 :             : 
    1388         [ -  + ]:       11905 :     if (!priv->init(context, gtype))
    1389                 :           0 :         return nullptr;
    1390                 :             : 
    1391                 :       11905 :     return function;
    1392                 :       11905 : }
    1393                 :             : 
    1394                 :             : }  // namespace Gjs
    1395                 :             : 
    1396                 :             : GJS_JSAPI_RETURN_CONVENTION
    1397                 :             : JSObject*
    1398                 :       11905 : gjs_define_function(JSContext       *context,
    1399                 :             :                     JS::HandleObject in_object,
    1400                 :             :                     GType            gtype,
    1401                 :             :                     GICallableInfo  *info)
    1402                 :             : {
    1403                 :       11905 :     std::string name;
    1404                 :             : 
    1405                 :             :     JS::RootedObject function(context,
    1406                 :       11905 :                               Gjs::Function::create(context, gtype, info));
    1407         [ -  + ]:       11905 :     if (!function)
    1408                 :           0 :         return NULL;
    1409                 :             : 
    1410         [ +  + ]:       11905 :     if (GI_IS_FUNCTION_INFO(info)) {
    1411                 :       11903 :         name = g_base_info_get_name(info);
    1412         [ +  - ]:           2 :     } else if (GI_IS_VFUNC_INFO(info)) {
    1413                 :           4 :         name = "vfunc_" + std::string(g_base_info_get_name(info));
    1414                 :             :     } else {
    1415                 :             :         g_assert_not_reached ();
    1416                 :             :     }
    1417                 :             : 
    1418         [ -  + ]:       11905 :     if (!JS_DefineProperty(context, in_object, name.c_str(), function,
    1419                 :             :                            GJS_MODULE_PROP_FLAGS)) {
    1420                 :           0 :         gjs_debug(GJS_DEBUG_GFUNCTION, "Failed to define function");
    1421                 :           0 :         function = NULL;
    1422                 :             :     }
    1423                 :             : 
    1424                 :       11905 :     return function;
    1425                 :       11905 : }
    1426                 :             : 
    1427                 :          21 : bool gjs_invoke_constructor_from_c(JSContext* context, GIFunctionInfo* info,
    1428                 :             :                                    JS::HandleObject obj,
    1429                 :             :                                    const JS::CallArgs& args,
    1430                 :             :                                    GIArgument* rvalue) {
    1431                 :          21 :     return Gjs::Function::invoke_constructor_uncached(context, info, obj, args,
    1432                 :          21 :                                                       rvalue);
    1433                 :             : }
        

Generated by: LCOV version 2.0-1