LCOV - code coverage report
Current view: top level - gi - arg-cache.cpp (source / functions) Coverage Total Hit
Test: gjs- Code Coverage Lines: 86.2 % 1179 1016
Test Date: 2024-04-29 05:18:28 Functions: 86.6 % 629 545
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 78.7 % 521 410

             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: 2013 Giovanni Campagna <scampa.giovanni@gmail.com>
       4                 :             : // SPDX-FileCopyrightText: 2020 Marco Trevisan <marco.trevisan@canonical.com>
       5                 :             : 
       6                 :             : #include <config.h>
       7                 :             : 
       8                 :             : #include <inttypes.h>
       9                 :             : #include <stddef.h>  // for size_t
      10                 :             : #include <stdint.h>
      11                 :             : #include <string.h>
      12                 :             : 
      13                 :             : #include <limits>
      14                 :             : #include <tuple>
      15                 :             : #include <type_traits>
      16                 :             : #include <unordered_set>  // for unordered_set::erase(), insert()
      17                 :             : #include <utility>
      18                 :             : 
      19                 :             : #include <ffi.h>
      20                 :             : #include <girepository.h>
      21                 :             : #include <glib.h>
      22                 :             : 
      23                 :             : #include <js/Conversions.h>
      24                 :             : #include <js/RootingAPI.h>
      25                 :             : #include <js/TypeDecls.h>
      26                 :             : #include <js/Utility.h>  // for UniqueChars
      27                 :             : #include <js/Value.h>
      28                 :             : #include <js/experimental/TypedData.h>
      29                 :             : #include <jsapi.h>        // for InformalValueTypeName, JS_TypeOfValue
      30                 :             : #include <jspubtd.h>      // for JSTYPE_FUNCTION
      31                 :             : 
      32                 :             : #include "gi/arg-cache.h"
      33                 :             : #include "gi/arg-inl.h"
      34                 :             : #include "gi/arg-types-inl.h"
      35                 :             : #include "gi/arg.h"
      36                 :             : #include "gi/boxed.h"
      37                 :             : #include "gi/closure.h"
      38                 :             : #include "gi/foreign.h"
      39                 :             : #include "gi/function.h"
      40                 :             : #include "gi/fundamental.h"
      41                 :             : #include "gi/gerror.h"
      42                 :             : #include "gi/gtype.h"
      43                 :             : #include "gi/js-value-inl.h"
      44                 :             : #include "gi/object.h"
      45                 :             : #include "gi/param.h"
      46                 :             : #include "gi/union.h"
      47                 :             : #include "gi/value.h"
      48                 :             : #include "gi/wrapperutils.h"  // for GjsTypecheckNoThrow
      49                 :             : #include "gjs/byteArray.h"
      50                 :             : #include "gjs/enum-utils.h"  // for operator&, operator|=, operator|
      51                 :             : #include "gjs/jsapi-util.h"
      52                 :             : #include "gjs/macros.h"
      53                 :             : #include "util/log.h"
      54                 :             : 
      55                 :             : enum ExpectedType {
      56                 :             :     OBJECT,
      57                 :             :     FUNCTION,
      58                 :             :     STRING,
      59                 :             :     LAST,
      60                 :             : };
      61                 :             : 
      62                 :             : static const char* expected_type_names[] = {"object", "function", "string"};
      63                 :             : static_assert(G_N_ELEMENTS(expected_type_names) == ExpectedType::LAST,
      64                 :             :               "Names must match the values in ExpectedType");
      65                 :             : 
      66                 :         333 : static constexpr void gjs_gi_argument_set_array_length(GITypeTag tag,
      67                 :             :                                                        GIArgument* arg,
      68                 :             :                                                        size_t value) {
      69   [ -  +  -  -  :         333 :     switch (tag) {
             +  +  +  +  
                      - ]
      70                 :           0 :         case GI_TYPE_TAG_INT8:
      71                 :           0 :             gjs_arg_set<int8_t>(arg, value);
      72                 :           0 :             break;
      73                 :           1 :         case GI_TYPE_TAG_UINT8:
      74                 :           1 :             gjs_arg_set<uint8_t>(arg, value);
      75                 :           1 :             break;
      76                 :           0 :         case GI_TYPE_TAG_INT16:
      77                 :           0 :             gjs_arg_set<int16_t>(arg, value);
      78                 :           0 :             break;
      79                 :           0 :         case GI_TYPE_TAG_UINT16:
      80                 :           0 :             gjs_arg_set<uint16_t>(arg, value);
      81                 :           0 :             break;
      82                 :          67 :         case GI_TYPE_TAG_INT32:
      83                 :          67 :             gjs_arg_set<int32_t>(arg, value);
      84                 :          67 :             break;
      85                 :           4 :         case GI_TYPE_TAG_UINT32:
      86                 :           4 :             gjs_arg_set<uint32_t>(arg, value);
      87                 :           4 :             break;
      88                 :          17 :         case GI_TYPE_TAG_INT64:
      89                 :          17 :             gjs_arg_set<int64_t>(arg, value);
      90                 :          17 :             break;
      91                 :         244 :         case GI_TYPE_TAG_UINT64:
      92                 :         244 :             gjs_arg_set<uint64_t>(arg, value);
      93                 :         244 :             break;
      94                 :           0 :         default:
      95                 :             :             g_assert_not_reached();
      96                 :             :     }
      97                 :         333 : }
      98                 :             : 
      99                 :             : GJS_JSAPI_RETURN_CONVENTION
     100                 :           0 : static bool report_typeof_mismatch(JSContext* cx, const char* arg_name,
     101                 :             :                                    JS::HandleValue value,
     102                 :             :                                    ExpectedType expected) {
     103                 :           0 :     gjs_throw(cx, "Expected type %s for argument '%s' but got type %s",
     104                 :           0 :               expected_type_names[expected], arg_name,
     105                 :             :               JS::InformalValueTypeName(value));
     106                 :           0 :     return false;
     107                 :             : }
     108                 :             : 
     109                 :             : GJS_JSAPI_RETURN_CONVENTION
     110                 :           0 : static bool report_gtype_mismatch(JSContext* cx, const char* arg_name,
     111                 :             :                                   JS::Value value, GType expected) {
     112                 :           0 :     gjs_throw(
     113                 :             :         cx, "Expected an object of type %s for argument '%s' but got type %s",
     114                 :             :         g_type_name(expected), arg_name, JS::InformalValueTypeName(value));
     115                 :           0 :     return false;
     116                 :             : }
     117                 :             : 
     118                 :             : GJS_JSAPI_RETURN_CONVENTION
     119                 :           2 : static bool report_invalid_null(JSContext* cx, const char* arg_name) {
     120                 :           2 :     gjs_throw(cx, "Argument %s may not be null", arg_name);
     121                 :           2 :     return false;
     122                 :             : }
     123                 :             : 
     124                 :             : // Overload operator| so that Visual Studio won't complain
     125                 :             : // when converting unsigned char to GjsArgumentFlags
     126                 :       25252 : GjsArgumentFlags operator|(
     127                 :             :     GjsArgumentFlags const& v1, GjsArgumentFlags const& v2) {
     128                 :       25252 :     return static_cast<GjsArgumentFlags>(std::underlying_type<GjsArgumentFlags>::type(v1) |
     129                 :       25252 :                                          std::underlying_type<GjsArgumentFlags>::type(v2));
     130                 :             : }
     131                 :             : 
     132                 :             : namespace Gjs {
     133                 :             : namespace Arg {
     134                 :             : 
     135                 :             : // Arguments Interfaces:
     136                 :             : //
     137                 :             : // Each of these types are meant to be used to extend each Gjs::Argument
     138                 :             : // implementation, taking advantage of the C++ multiple inheritance.
     139                 :             : 
     140                 :             : struct BasicType {
     141                 :        1049 :     constexpr BasicType() : m_tag(GI_TYPE_TAG_VOID) {}
     142                 :             :     constexpr explicit BasicType(GITypeTag tag) : m_tag(tag) {}
     143                 :             :     constexpr operator GITypeTag() const { return m_tag; }
     144                 :             : 
     145                 :             :     GITypeTag m_tag : 5;
     146                 :             : };
     147                 :             : 
     148                 :             : struct TypeInfo {
     149                 :             :     constexpr GITypeInfo* type_info() const {
     150                 :             :         // Should be const GITypeInfo*, but G-I APIs won't accept that
     151                 :             :         return const_cast<GITypeInfo*>(&m_type_info);
     152                 :             :     }
     153                 :             : 
     154                 :             :     GITypeInfo m_type_info{};
     155                 :             : };
     156                 :             : 
     157                 :             : struct Transferable {
     158                 :       13530 :     constexpr Transferable() : m_transfer(GI_TRANSFER_NOTHING) {}
     159                 :             :     constexpr explicit Transferable(GITransfer transfer)
     160                 :             :         : m_transfer(transfer) {}
     161                 :             :     GITransfer m_transfer : 2;
     162                 :             : };
     163                 :             : 
     164                 :             : struct Nullable {
     165                 :       17802 :     constexpr Nullable() : m_nullable(false) {}
     166                 :             :     bool m_nullable : 1;
     167                 :             : 
     168                 :             :     bool handle_nullable(JSContext* cx, GIArgument* arg, const char* arg_name);
     169                 :             : 
     170                 :         516 :     constexpr GjsArgumentFlags flags() const {
     171         [ +  + ]:         516 :         return m_nullable ? GjsArgumentFlags::MAY_BE_NULL
     172                 :         516 :                           : GjsArgumentFlags::NONE;
     173                 :             :     }
     174                 :             : };
     175                 :             : 
     176                 :             : struct Positioned {
     177                 :        1757 :     void set_arg_pos(int pos) {
     178                 :        1757 :         g_assert(pos <= Argument::MAX_ARGS &&
     179                 :             :                  "No more than 253 arguments allowed");
     180                 :        1757 :         m_arg_pos = pos;
     181                 :        1757 :     }
     182                 :             : 
     183                 :         716 :     constexpr bool set_out_parameter(GjsFunctionCallState* state,
     184                 :             :                                      GIArgument* arg) {
     185                 :         716 :         gjs_arg_unset<void*>(&state->out_cvalue(m_arg_pos));
     186                 :         716 :         gjs_arg_set(arg, &gjs_arg_member<void*>(&state->out_cvalue(m_arg_pos)));
     187                 :         716 :         return true;
     188                 :             :     }
     189                 :             : 
     190                 :          43 :     constexpr bool set_inout_parameter(GjsFunctionCallState* state,
     191                 :             :                                        GIArgument* arg) {
     192                 :          43 :         state->out_cvalue(m_arg_pos) = state->inout_original_cvalue(m_arg_pos) =
     193                 :             :             *arg;
     194                 :          43 :         gjs_arg_set(arg, &state->out_cvalue(m_arg_pos));
     195                 :          43 :         return true;
     196                 :             :     }
     197                 :             : 
     198                 :             :     uint8_t m_arg_pos = 0;
     199                 :             : };
     200                 :             : 
     201                 :             : struct Array : BasicType {
     202                 :             :     uint8_t m_length_pos = 0;
     203                 :             :     GIDirection m_length_direction : 2;
     204                 :             : 
     205                 :        1049 :     Array() : BasicType(), m_length_direction(GI_DIRECTION_IN) {}
     206                 :             : 
     207                 :        1049 :     void set_array_length(int pos, GITypeTag tag, GIDirection direction) {
     208                 :        1049 :         g_assert(pos >= 0 && pos <= Argument::MAX_ARGS &&
     209                 :             :                  "No more than 253 arguments allowed");
     210                 :        1049 :         m_length_pos = pos;
     211                 :        1049 :         m_length_direction = direction;
     212                 :        1049 :         m_tag = tag;
     213                 :        1049 :     }
     214                 :             : };
     215                 :             : 
     216                 :             : struct HasIntrospectionInfo {
     217                 :        1125 :     constexpr explicit HasIntrospectionInfo(GIBaseInfo* info,
     218                 :             :                                             const GjsAutoTakeOwnership& add_ref)
     219                 :        1125 :         : m_info(info, add_ref) {}
     220                 :             :     constexpr explicit HasIntrospectionInfo(GIBaseInfo* info) : m_info(info) {}
     221                 :             : 
     222                 :             :     GjsAutoBaseInfo m_info;
     223                 :             : };
     224                 :             : 
     225                 :             : // boxed / union / GObject
     226                 :             : struct GTypedType {
     227                 :        6865 :     explicit GTypedType(GType gtype) : m_gtype(gtype) {}
     228                 :       95979 :     constexpr GType gtype() const { return m_gtype; }
     229                 :             : 
     230                 :             :  protected:
     231                 :             :     GType m_gtype;
     232                 :             : };
     233                 :             : 
     234                 :             : struct RegisteredType : GTypedType {
     235                 :           7 :     RegisteredType(GType gtype, GIInfoType info_type)
     236                 :           7 :         : GTypedType(gtype), m_info_type(info_type) {}
     237                 :        6379 :     explicit RegisteredType(GIRegisteredTypeInfo* info)
     238                 :        6379 :         : GTypedType(g_registered_type_info_get_g_type(info)),
     239                 :        6379 :           m_info_type(g_base_info_get_type(info)) {
     240                 :        6379 :         g_assert(m_gtype != G_TYPE_NONE &&
     241                 :             :                  "Use RegisteredInterface for this type");
     242                 :        6379 :     }
     243                 :             : 
     244                 :             :     GIInfoType m_info_type : 5;
     245                 :             : };
     246                 :             : 
     247                 :             : struct RegisteredInterface : HasIntrospectionInfo, GTypedType {
     248                 :         473 :     explicit RegisteredInterface(GIRegisteredTypeInfo* info)
     249                 :         946 :         : HasIntrospectionInfo(info, GjsAutoTakeOwnership{}),
     250                 :         473 :           GTypedType(g_registered_type_info_get_g_type(m_info)) {}
     251                 :             : };
     252                 :             : 
     253                 :             : struct Callback : Nullable, HasIntrospectionInfo {
     254                 :         645 :     explicit Callback(GICallbackInfo* info)
     255                 :        1290 :         : HasIntrospectionInfo(info, GjsAutoTakeOwnership{}),
     256                 :         645 :           m_scope(GI_SCOPE_TYPE_INVALID) {}
     257                 :             : 
     258                 :         644 :     inline void set_callback_destroy_pos(int pos) {
     259                 :         644 :         g_assert(pos <= Argument::MAX_ARGS &&
     260                 :             :                  "No more than 253 arguments allowed");
     261         [ +  + ]:         644 :         m_destroy_pos = pos < 0 ? Argument::ABSENT : pos;
     262                 :         644 :     }
     263                 :             : 
     264                 :         494 :     [[nodiscard]] constexpr bool has_callback_destroy() {
     265                 :         494 :         return m_destroy_pos != Argument::ABSENT;
     266                 :             :     }
     267                 :             : 
     268                 :         644 :     inline void set_callback_closure_pos(int pos) {
     269                 :         644 :         g_assert(pos <= Argument::MAX_ARGS &&
     270                 :             :                  "No more than 253 arguments allowed");
     271         [ +  + ]:         644 :         m_closure_pos = pos < 0 ? Argument::ABSENT : pos;
     272                 :         644 :     }
     273                 :             : 
     274                 :         247 :     [[nodiscard]] constexpr bool has_callback_closure() {
     275                 :         247 :         return m_closure_pos != Argument::ABSENT;
     276                 :             :     }
     277                 :             : 
     278                 :             :     uint8_t m_closure_pos = Argument::ABSENT;
     279                 :             :     uint8_t m_destroy_pos = Argument::ABSENT;
     280                 :             :     GIScopeType m_scope : 3;
     281                 :             : };
     282                 :             : 
     283                 :             : struct Enum {
     284                 :             :     explicit Enum(GIEnumInfo*);
     285                 :             :     bool m_unsigned : 1;
     286                 :             :     uint32_t m_min = 0;
     287                 :             :     uint32_t m_max = 0;
     288                 :             : };
     289                 :             : 
     290                 :             : struct Flags {
     291                 :             :     explicit Flags(GIEnumInfo*);
     292                 :             :     unsigned m_mask = 0;
     293                 :             : };
     294                 :             : 
     295                 :             : struct CallerAllocates {
     296                 :             :     size_t m_allocates_size = 0;
     297                 :             : };
     298                 :             : 
     299                 :             : // Gjs::Arguments:
     300                 :             : //
     301                 :             : // Each argument, irrespective of the direction, is processed in three phases:
     302                 :             : // - before calling the function [in]
     303                 :             : // - after calling it, when converting the return value and out arguments [out]
     304                 :             : // - at the end of the invocation, to release any allocated memory [release]
     305                 :             : //
     306                 :             : // Some types don't have direction (for example, caller_allocates is only out,
     307                 :             : // and callback is only in), in which case it is implied.
     308                 :             : 
     309                 :             : struct SkipAll : Argument {
     310                 :         657 :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     311                 :             :             JS::HandleValue) override {
     312                 :         657 :         return skip();
     313                 :             :     }
     314                 :             : 
     315                 :       32025 :     bool out(JSContext*, GjsFunctionCallState*, GIArgument*,
     316                 :             :              JS::MutableHandleValue) override {
     317                 :       32025 :         return skip();
     318                 :             :     }
     319                 :             : 
     320                 :       41155 :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     321                 :             :                  GIArgument*) override {
     322                 :       41155 :         return skip();
     323                 :             :     }
     324                 :             : 
     325                 :             :  protected:
     326                 :      174938 :     constexpr bool skip() { return true; }
     327                 :             : };
     328                 :             : 
     329                 :             : struct Generic : SkipAll, Transferable, TypeInfo {};
     330                 :             : 
     331                 :             : struct GenericIn : Generic {
     332                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     333                 :             :             JS::HandleValue) override;
     334                 :           0 :     bool out(JSContext* cx, GjsFunctionCallState*, GIArgument*,
     335                 :             :              JS::MutableHandleValue) override {
     336                 :           0 :         return invalid(cx, G_STRFUNC);
     337                 :             :     }
     338                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     339                 :             :                  GIArgument*) override;
     340                 :             : };
     341                 :             : 
     342                 :             : struct GenericInOut : GenericIn, Positioned {
     343                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     344                 :             :             JS::HandleValue) override;
     345                 :             :     bool out(JSContext*, GjsFunctionCallState*, GIArgument*,
     346                 :             :              JS::MutableHandleValue) override;
     347                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     348                 :             :                  GIArgument*) override;
     349                 :             : };
     350                 :             : 
     351                 :             : struct GenericOut : GenericInOut {
     352                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     353                 :             :             JS::HandleValue) override;
     354                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     355                 :             :                  GIArgument*) override;
     356                 :             : 
     357                 :       21284 :     GITypeTag return_tag() const override {
     358                 :       21284 :         return g_type_info_get_tag(&const_cast<GenericOut*>(this)->m_type_info);
     359                 :             :     }
     360                 :       21284 :     const GITypeInfo* return_type() const override { return &m_type_info; }
     361                 :             : };
     362                 :             : 
     363                 :             : struct GenericReturn : ReturnValue {
     364                 :             :     // No in!
     365                 :           0 :     bool in(JSContext* cx, GjsFunctionCallState*, GIArgument*,
     366                 :             :             JS::HandleValue) override {
     367                 :           0 :         return invalid(cx, G_STRFUNC);
     368                 :             :     }
     369                 :             : };
     370                 :             : 
     371                 :             : template <typename T, GITypeTag TAG = GI_TYPE_TAG_VOID>
     372                 :             : struct NumericOut : SkipAll, Positioned {
     373                 :             :     static_assert(std::is_arithmetic_v<T>, "Not arithmetic type");
     374                 :         541 :     bool in(JSContext*, GjsFunctionCallState* state, GIArgument* arg,
     375                 :             :             JS::HandleValue) override {
     376                 :         541 :         return set_out_parameter(state, arg);
     377                 :             :     }
     378                 :         541 :     bool out(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
     379                 :             :              JS::MutableHandleValue value) override {
     380                 :         541 :         return Gjs::c_value_to_js_checked<T, TAG>(cx, gjs_arg_get<T>(arg),
     381                 :         541 :                                                   value);
     382                 :             :     }
     383                 :             : };
     384                 :             : 
     385                 :             : using BooleanOut = NumericOut<gboolean, GI_TYPE_TAG_BOOLEAN>;
     386                 :             : 
     387                 :             : template <typename T, GITypeTag TAG = GI_TYPE_TAG_VOID>
     388                 :             : struct NumericReturn : SkipAll {
     389                 :             :     static_assert(std::is_arithmetic_v<T>, "Not arithmetic type");
     390                 :           0 :     bool in(JSContext* cx, GjsFunctionCallState*, GIArgument*,
     391                 :             :             JS::HandleValue) override {
     392                 :           0 :         return invalid(cx, G_STRFUNC);
     393                 :             :     }
     394                 :       13680 :     bool out(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
     395                 :             :              JS::MutableHandleValue value) override {
     396                 :       13680 :         return Gjs::c_value_to_js_checked<T, TAG>(cx, gjs_arg_get<T>(arg),
     397                 :       13680 :                                                   value);
     398                 :             :     }
     399                 :       13680 :     GITypeTag return_tag() const override { return TAG; }
     400                 :             : };
     401                 :             : 
     402                 :             : using BooleanReturn = NumericReturn<gboolean, GI_TYPE_TAG_BOOLEAN>;
     403                 :             : 
     404                 :             : struct SimpleOut : SkipAll, Positioned {
     405                 :          21 :     bool in(JSContext*, GjsFunctionCallState* state, GIArgument* arg,
     406                 :             :             JS::HandleValue) override {
     407                 :          21 :         return set_out_parameter(state, arg);
     408                 :             :     };
     409                 :             : };
     410                 :             : 
     411                 :             : struct ExplicitArray : GenericOut, Array, Nullable {
     412                 :         338 :     GjsArgumentFlags flags() const override {
     413                 :         338 :         return Argument::flags() | Nullable::flags();
     414                 :             :     }
     415                 :             : };
     416                 :             : 
     417                 :             : struct ExplicitArrayIn : ExplicitArray {
     418                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     419                 :             :             JS::HandleValue) override;
     420                 :         317 :     bool out(JSContext*, GjsFunctionCallState*, GIArgument*,
     421                 :             :              JS::MutableHandleValue) override {
     422                 :         317 :         return skip();
     423                 :             :     };
     424                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     425                 :             :                  GIArgument*) override;
     426                 :             : };
     427                 :             : 
     428                 :             : struct ExplicitArrayInOut : ExplicitArrayIn {
     429                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     430                 :             :             JS::HandleValue) override;
     431                 :             :     bool out(JSContext*, GjsFunctionCallState*, GIArgument*,
     432                 :             :              JS::MutableHandleValue) override;
     433                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     434                 :             :                  GIArgument*) override;
     435                 :             : };
     436                 :             : 
     437                 :             : struct ExplicitArrayOut : ExplicitArrayInOut {
     438                 :           0 :     bool in(JSContext* cx, GjsFunctionCallState*, GIArgument*,
     439                 :             :             JS::HandleValue) override {
     440                 :           0 :         return invalid(cx, G_STRFUNC);
     441                 :             :     }
     442                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     443                 :             :                  GIArgument*) override;
     444                 :             : };
     445                 :             : 
     446                 :             : struct ReturnArray : ExplicitArrayOut {
     447                 :          14 :     bool in(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
     448                 :             :             JS::HandleValue value) override {
     449         [ -  + ]:          14 :         if (m_length_direction != GI_DIRECTION_OUT) {
     450                 :           0 :             gjs_throw(cx,
     451                 :             :                       "Using different length argument direction for array %s"
     452                 :             :                       "is not supported for out arrays",
     453                 :             :                       m_arg_name);
     454                 :           0 :             return false;
     455                 :             :         }
     456                 :          14 :         return GenericOut::in(cx, state, arg, value);
     457                 :             :     };
     458                 :             : };
     459                 :             : 
     460                 :             : using ArrayLengthOut = SimpleOut;
     461                 :             : 
     462                 :             : struct FallbackIn : GenericIn, Nullable {
     463                 :          35 :     bool out(JSContext*, GjsFunctionCallState*, GIArgument*,
     464                 :             :              JS::MutableHandleValue) override {
     465                 :          35 :         return skip();
     466                 :             :     }
     467                 :             : 
     468                 :          35 :     GjsArgumentFlags flags() const override {
     469                 :          35 :         return Argument::flags() | Nullable::flags();
     470                 :             :     }
     471                 :             : };
     472                 :             : 
     473                 :             : using FallbackInOut = GenericInOut;
     474                 :             : using FallbackOut = GenericOut;
     475                 :             : 
     476                 :             : struct NotIntrospectable : GenericIn {
     477                 :          67 :     explicit NotIntrospectable(NotIntrospectableReason reason)
     478                 :          67 :         : m_reason(reason) {}
     479                 :             :     NotIntrospectableReason m_reason;
     480                 :             : 
     481                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     482                 :             :             JS::HandleValue) override;
     483                 :             : };
     484                 :             : 
     485                 :             : struct NullableIn : SkipAll, Nullable {
     486                 :       11987 :     inline bool in(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
     487                 :             :                    JS::HandleValue) override {
     488                 :       11987 :         return handle_nullable(cx, arg, m_arg_name);
     489                 :             :     }
     490                 :             : 
     491                 :         129 :     GjsArgumentFlags flags() const override {
     492                 :         129 :         return Argument::flags() | Nullable::flags();
     493                 :             :     }
     494                 :             : };
     495                 :             : 
     496                 :             : struct Instance : NullableIn {
     497                 :             :     //  Some calls accept null for the instance (thus we inherit from
     498                 :             :     //  NullableIn), but generally in an object oriented language it's wrong to
     499                 :             :     //  call a method on null.
     500                 :             :     //  As per this we actually default to SkipAll methods.
     501                 :             : 
     502                 :           0 :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     503                 :             :             JS::HandleValue) override {
     504                 :           0 :         return skip();
     505                 :             :     }
     506                 :       38164 :     bool out(JSContext*, GjsFunctionCallState*, GIArgument*,
     507                 :             :              JS::MutableHandleValue) override {
     508                 :       38164 :         return skip();
     509                 :             :     }
     510                 :        3096 :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     511                 :             :                  GIArgument*) override {
     512                 :        3096 :         return skip();
     513                 :             :     }
     514                 :             : 
     515                 :       35478 :     const Instance* as_instance() const override { return this; }
     516                 :             : 
     517                 :             :     //  The instance GType can be useful only in few cases such as GObjects and
     518                 :             :     //  GInterfaces, so we don't store it by default, unless needed.
     519                 :             :     //  See Function's code to see where this is relevant.
     520                 :         248 :     virtual GType gtype() const { return G_TYPE_NONE; }
     521                 :             : };
     522                 :             : 
     523                 :             : struct EnumIn : Instance, Enum {
     524                 :             :     using Enum::Enum;
     525                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     526                 :             :             JS::HandleValue) override;
     527                 :             : };
     528                 :             : 
     529                 :             : struct FlagsIn : Instance, Flags {
     530                 :             :     using Flags::Flags;
     531                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     532                 :             :             JS::HandleValue) override;
     533                 :             : };
     534                 :             : 
     535                 :             : struct RegisteredIn : Instance, RegisteredType, Transferable {
     536                 :             :     using RegisteredType::RegisteredType;
     537                 :             : 
     538                 :       35230 :     GType gtype() const override { return RegisteredType::gtype(); }
     539                 :             : };
     540                 :             : 
     541                 :             : struct RegisteredInterfaceIn : Instance, RegisteredInterface, Transferable {
     542                 :             :     using RegisteredInterface::RegisteredInterface;
     543                 :             : 
     544                 :           0 :     GType gtype() const override { return RegisteredInterface::gtype(); }
     545                 :             : };
     546                 :             : 
     547                 :             : struct ForeignStructInstanceIn : RegisteredInterfaceIn {
     548                 :             :     using RegisteredInterfaceIn::RegisteredInterfaceIn;
     549                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     550                 :             :             JS::HandleValue) override;
     551                 :             : };
     552                 :             : 
     553                 :             : struct ForeignStructIn : ForeignStructInstanceIn {
     554                 :             :     using ForeignStructInstanceIn::ForeignStructInstanceIn;
     555                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     556                 :             :                  GIArgument*) override;
     557                 :             : };
     558                 :             : 
     559                 :             : struct FallbackInterfaceIn : RegisteredInterfaceIn, TypeInfo {
     560                 :             :     using RegisteredInterfaceIn::RegisteredInterfaceIn;
     561                 :             : 
     562                 :         127 :     bool in(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
     563                 :             :             JS::HandleValue value) override {
     564                 :         254 :         return gjs_value_to_gi_argument(cx, value, &m_type_info, m_arg_name,
     565                 :         127 :                                         GJS_ARGUMENT_ARGUMENT, m_transfer,
     566                 :         254 :                                         flags(), arg);
     567                 :             :     }
     568                 :             : };
     569                 :             : 
     570                 :             : struct BoxedInTransferNone : RegisteredIn {
     571                 :             :     using RegisteredIn::RegisteredIn;
     572                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     573                 :             :             JS::HandleValue) override;
     574                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     575                 :             :                  GIArgument*) override;
     576                 :             : 
     577                 :       47122 :     virtual GIBaseInfo* info() const { return nullptr; }
     578                 :             : };
     579                 :             : 
     580                 :             : struct BoxedIn : BoxedInTransferNone {
     581                 :             :     using BoxedInTransferNone::BoxedInTransferNone;
     582                 :             :     // This is a smart argument, no release needed
     583                 :       58807 :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     584                 :             :                  GIArgument*) override {
     585                 :       58807 :         return skip();
     586                 :             :     }
     587                 :             : };
     588                 :             : 
     589                 :             : struct UnregisteredBoxedIn : BoxedIn, HasIntrospectionInfo {
     590                 :           7 :     explicit UnregisteredBoxedIn(GIStructInfo* info)
     591                 :           7 :         : BoxedIn(g_registered_type_info_get_g_type(info),
     592                 :             :                   g_base_info_get_type(info)),
     593                 :           7 :           HasIntrospectionInfo(info, GjsAutoTakeOwnership{}) {}
     594                 :             :     // This is a smart argument, no release needed
     595                 :           8 :     GIBaseInfo* info() const override { return m_info; }
     596                 :             : };
     597                 :             : 
     598                 :             : struct GValueIn : BoxedIn {
     599                 :             :     using BoxedIn::BoxedIn;
     600                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     601                 :             :             JS::HandleValue) override;
     602                 :             : };
     603                 :             : 
     604                 :             : struct GValueInTransferNone : GValueIn {
     605                 :             :     using GValueIn::GValueIn;
     606                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     607                 :             :                  GIArgument*) override;
     608                 :             : };
     609                 :             : 
     610                 :             : struct GClosureInTransferNone : BoxedInTransferNone {
     611                 :             :     using BoxedInTransferNone::BoxedInTransferNone;
     612                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     613                 :             :             JS::HandleValue) override;
     614                 :             : };
     615                 :             : 
     616                 :             : struct GClosureIn : GClosureInTransferNone {
     617                 :             :     using GClosureInTransferNone::GClosureInTransferNone;
     618                 :           0 :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     619                 :             :                  GIArgument*) override {
     620                 :           0 :         return skip();
     621                 :             :     }
     622                 :             : };
     623                 :             : 
     624                 :             : struct GBytesIn : BoxedIn {
     625                 :             :     using BoxedIn::BoxedIn;
     626                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     627                 :             :             JS::HandleValue) override;
     628                 :             :     bool release(JSContext* cx, GjsFunctionCallState* state, GIArgument* in_arg,
     629                 :             :                  GIArgument* out_arg) override;
     630                 :             : };
     631                 :             : 
     632                 :             : struct GBytesInTransferNone : GBytesIn {
     633                 :             :     using GBytesIn::GBytesIn;
     634                 :          36 :     bool release(JSContext* cx, GjsFunctionCallState* state, GIArgument* in_arg,
     635                 :             :                  GIArgument* out_arg) override {
     636                 :          36 :         return BoxedInTransferNone::release(cx, state, in_arg, out_arg);
     637                 :             :     }
     638                 :             : };
     639                 :             : 
     640                 :             : struct ObjectIn : RegisteredIn {
     641                 :             :     using RegisteredIn::RegisteredIn;
     642                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     643                 :             :             JS::HandleValue) override;
     644                 :             :     // This is a smart argument, no release needed
     645                 :             : };
     646                 :             : 
     647                 :             : struct InterfaceIn : RegisteredIn {
     648                 :             :     using RegisteredIn::RegisteredIn;
     649                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     650                 :             :             JS::HandleValue) override;
     651                 :             :     // This is a smart argument, no release needed
     652                 :             : };
     653                 :             : 
     654                 :             : struct FundamentalIn : RegisteredIn {
     655                 :             :     using RegisteredIn::RegisteredIn;
     656                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     657                 :             :             JS::HandleValue) override;
     658                 :             :     // This is a smart argument, no release needed
     659                 :             : };
     660                 :             : 
     661                 :             : struct UnionIn : RegisteredIn {
     662                 :             :     using RegisteredIn::RegisteredIn;
     663                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     664                 :             :             JS::HandleValue) override;
     665                 :             :     // This is a smart argument, no release needed
     666                 :             : };
     667                 :             : 
     668                 :             : struct NullIn : NullableIn {
     669                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     670                 :             :             JS::HandleValue) override;
     671                 :             : };
     672                 :             : 
     673                 :             : struct BooleanIn : SkipAll {
     674                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     675                 :             :             JS::HandleValue) override;
     676                 :             : };
     677                 :             : 
     678                 :             : template <typename T>
     679                 :             : struct NumericIn : SkipAll {
     680                 :             :     static_assert(std::is_arithmetic_v<T>, "Not arithmetic type");
     681                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     682                 :             :             JS::HandleValue) override;
     683                 :             : };
     684                 :             : 
     685                 :             : template <typename T, GITypeTag TAG = GI_TYPE_TAG_VOID>
     686                 :             : struct NumericInOut : NumericIn<T>, Positioned {
     687                 :             :     static_assert(std::is_arithmetic_v<T>, "Not arithmetic type");
     688                 :          26 :     bool in(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
     689                 :             :             JS::HandleValue value) override {
     690         [ -  + ]:          26 :         if (!NumericIn<T>::in(cx, state, arg, value))
     691                 :           0 :             return false;
     692                 :             : 
     693                 :          26 :         return set_inout_parameter(state, arg);
     694                 :             :     }
     695                 :          26 :     bool out(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
     696                 :             :              JS::MutableHandleValue value) override {
     697                 :          26 :         return Gjs::c_value_to_js_checked<T, TAG>(cx, gjs_arg_get<T>(arg),
     698                 :          26 :                                                   value);
     699                 :             :     }
     700                 :             : };
     701                 :             : 
     702                 :             : using BooleanInOut = NumericInOut<gboolean, GI_TYPE_TAG_BOOLEAN>;
     703                 :             : 
     704                 :             : struct UnicharIn : SkipAll {
     705                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     706                 :             :             JS::HandleValue) override;
     707                 :             : };
     708                 :             : 
     709                 :             : struct GTypeIn : SkipAll {
     710                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     711                 :             :             JS::HandleValue) override;
     712                 :             : };
     713                 :             : 
     714                 :             : template <GITypeTag TAG = GI_TYPE_TAG_UTF8>
     715                 :             : struct StringInTransferNone : NullableIn {
     716                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     717                 :             :             JS::HandleValue) override;
     718                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     719                 :             :                  GIArgument*) override;
     720                 :             : };
     721                 :             : 
     722                 :             : struct StringIn : StringInTransferNone<GI_TYPE_TAG_UTF8> {
     723                 :           0 :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     724                 :             :                  GIArgument*) override {
     725                 :           0 :         return skip();
     726                 :             :     }
     727                 :             : };
     728                 :             : 
     729                 :             : template <GITransfer TRANSFER = GI_TRANSFER_NOTHING>
     730                 :             : struct StringOutBase : SkipAll {
     731                 :         704 :     bool out(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
     732                 :             :              JS::MutableHandleValue value) override {
     733                 :         704 :         return Gjs::c_value_to_js(cx, gjs_arg_get<char*>(arg), value);
     734                 :             :     }
     735                 :         704 :     bool release(JSContext* cx, GjsFunctionCallState*, GIArgument*,
     736                 :             :                  GIArgument* out_arg [[maybe_unused]]) override {
     737                 :             :         if constexpr (TRANSFER == GI_TRANSFER_NOTHING) {
     738                 :         667 :             return skip();
     739                 :             :         } else if constexpr (TRANSFER == GI_TRANSFER_EVERYTHING) {
     740         [ +  + ]:          37 :             g_clear_pointer(&gjs_arg_member<char*>(out_arg), g_free);
     741                 :          37 :             return true;
     742                 :             :         } else {
     743                 :             :             return invalid(cx, G_STRFUNC);
     744                 :             :         }
     745                 :             :     }
     746                 :             : };
     747                 :             : 
     748                 :             : template <GITransfer TRANSFER = GI_TRANSFER_NOTHING>
     749                 :             : struct StringReturn : StringOutBase<TRANSFER> {
     750                 :           0 :     bool in(JSContext* cx, GjsFunctionCallState*, GIArgument*,
     751                 :             :             JS::HandleValue) override {
     752                 :           0 :         return Argument::invalid(cx, G_STRFUNC);
     753                 :             :     }
     754                 :             : 
     755                 :         688 :     GITypeTag return_tag() const override { return GI_TYPE_TAG_UTF8; }
     756                 :             : };
     757                 :             : 
     758                 :             : template <GITransfer TRANSFER = GI_TRANSFER_NOTHING>
     759                 :             : struct StringOut : StringOutBase<TRANSFER>, Positioned {
     760                 :          16 :     bool in(JSContext*, GjsFunctionCallState* state, GIArgument* arg,
     761                 :             :             JS::HandleValue) override {
     762                 :          16 :         return set_out_parameter(state, arg);
     763                 :             :     }
     764                 :             : };
     765                 :             : 
     766                 :             : using FilenameInTransferNone = StringInTransferNone<GI_TYPE_TAG_FILENAME>;
     767                 :             : 
     768                 :             : struct FilenameIn : FilenameInTransferNone {
     769                 :           0 :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     770                 :             :                  GIArgument*) override {
     771                 :           0 :         return skip();
     772                 :             :     }
     773                 :             : };
     774                 :             : 
     775                 :             : // .out is ignored for the instance parameter
     776                 :             : struct GTypeStructInstanceIn : Instance {
     777                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     778                 :             :             JS::HandleValue) override;
     779                 :             :     // no out
     780                 :           0 :     bool out(JSContext* cx, GjsFunctionCallState*, GIArgument*,
     781                 :             :              JS::MutableHandleValue) override {
     782                 :           0 :         return invalid(cx, G_STRFUNC);
     783                 :             :     };
     784                 :             : };
     785                 :             : 
     786                 :             : struct ParamInstanceIn : Instance, Transferable {
     787                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     788                 :             :             JS::HandleValue) override;
     789                 :             :     // no out
     790                 :           0 :     bool out(JSContext* cx, GjsFunctionCallState*, GIArgument*,
     791                 :             :              JS::MutableHandleValue) override {
     792                 :           0 :         return invalid(cx, G_STRFUNC);
     793                 :             :     };
     794                 :             : };
     795                 :             : 
     796                 :             : struct CallbackIn : SkipAll, Callback {
     797                 :             :     using Callback::Callback;
     798                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     799                 :             :             JS::HandleValue) override;
     800                 :             : 
     801                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     802                 :             :                  GIArgument*) override;
     803                 :             :  private:
     804                 :             :     ffi_closure *m_ffi_closure;
     805                 :             : };
     806                 :             : 
     807                 :             : using CArrayIn = ExplicitArrayIn;
     808                 :             : 
     809                 :             : using CArrayInOut = ExplicitArrayInOut;
     810                 :             : 
     811                 :             : using CArrayOut = ReturnArray;
     812                 :             : 
     813                 :             : struct CallerAllocatesOut : GenericOut, CallerAllocates {
     814                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     815                 :             :             JS::HandleValue) override;
     816                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     817                 :             :                  GIArgument*) override;
     818                 :             : 
     819                 :           0 :     GjsArgumentFlags flags() const override {
     820                 :           0 :         return GenericOut::flags() | GjsArgumentFlags::CALLER_ALLOCATES;
     821                 :             :     }
     822                 :             : };
     823                 :             : 
     824                 :             : struct BoxedCallerAllocatesOut : CallerAllocatesOut, GTypedType {
     825                 :             :     using GTypedType::GTypedType;
     826                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     827                 :             :                  GIArgument*) override;
     828                 :             : };
     829                 :             : 
     830                 :             : struct ZeroTerminatedArrayInOut : GenericInOut {
     831                 :           2 :     bool release(JSContext* cx, GjsFunctionCallState* state, GIArgument*,
     832                 :             :                  GIArgument* out_arg) override {
     833                 :             :         GITransfer transfer =
     834         [ +  - ]:           2 :             state->call_completed() ? m_transfer : GI_TRANSFER_NOTHING;
     835                 :           2 :         GIArgument* original_out_arg = &state->inout_original_cvalue(m_arg_pos);
     836         [ -  + ]:           2 :         if (!gjs_gi_argument_release_in_array(cx, transfer, &m_type_info,
     837                 :             :                                               original_out_arg))
     838                 :           0 :             return false;
     839                 :             : 
     840                 :           2 :         transfer =
     841         [ +  - ]:           2 :             state->call_completed() ? m_transfer : GI_TRANSFER_EVERYTHING;
     842                 :           2 :         return gjs_gi_argument_release_out_array(cx, transfer, &m_type_info,
     843                 :           2 :                                                  out_arg);
     844                 :             :     }
     845                 :             : };
     846                 :             : 
     847                 :             : struct ZeroTerminatedArrayIn : GenericIn, Nullable {
     848                 :          10 :     bool out(JSContext*, GjsFunctionCallState*, GIArgument*,
     849                 :             :              JS::MutableHandleValue) override {
     850                 :          10 :         return skip();
     851                 :             :     }
     852                 :             : 
     853                 :          10 :     bool release(JSContext* cx, GjsFunctionCallState* state, GIArgument* in_arg,
     854                 :             :                  GIArgument*) override {
     855                 :             :         GITransfer transfer =
     856         [ +  + ]:          10 :             state->call_completed() ? m_transfer : GI_TRANSFER_NOTHING;
     857                 :             : 
     858                 :          10 :         return gjs_gi_argument_release_in_array(cx, transfer, &m_type_info,
     859                 :          10 :                                                 in_arg);
     860                 :             :     }
     861                 :             : 
     862                 :          14 :     GjsArgumentFlags flags() const override {
     863                 :          14 :         return Argument::flags() | Nullable::flags();
     864                 :             :     }
     865                 :             : };
     866                 :             : 
     867                 :             : struct FixedSizeArrayIn : GenericIn {
     868                 :           5 :     bool out(JSContext*, GjsFunctionCallState*, GIArgument*,
     869                 :             :              JS::MutableHandleValue) override {
     870                 :           5 :         return skip();
     871                 :             :     }
     872                 :             : 
     873                 :           5 :     bool release(JSContext* cx, GjsFunctionCallState* state, GIArgument* in_arg,
     874                 :             :                  GIArgument*) override {
     875                 :             :         GITransfer transfer =
     876         [ +  - ]:           5 :             state->call_completed() ? m_transfer : GI_TRANSFER_NOTHING;
     877                 :             : 
     878                 :           5 :         int size = g_type_info_get_array_fixed_size(&m_type_info);
     879                 :           5 :         return gjs_gi_argument_release_in_array(cx, transfer, &m_type_info,
     880                 :           5 :                                                 size, in_arg);
     881                 :             :     }
     882                 :             : };
     883                 :             : 
     884                 :             : struct FixedSizeArrayInOut : GenericInOut {
     885                 :           1 :     bool release(JSContext* cx, GjsFunctionCallState* state, GIArgument*,
     886                 :             :                  GIArgument* out_arg) override {
     887                 :             :         GITransfer transfer =
     888         [ +  - ]:           1 :             state->call_completed() ? m_transfer : GI_TRANSFER_NOTHING;
     889                 :           1 :         GIArgument* original_out_arg = &state->inout_original_cvalue(m_arg_pos);
     890                 :           1 :         int size = g_type_info_get_array_fixed_size(&m_type_info);
     891         [ -  + ]:           1 :         if (!gjs_gi_argument_release_in_array(cx, transfer, &m_type_info, size,
     892                 :             :                                               original_out_arg))
     893                 :           0 :             return false;
     894                 :             : 
     895                 :           1 :         transfer =
     896         [ +  - ]:           1 :             state->call_completed() ? m_transfer : GI_TRANSFER_EVERYTHING;
     897                 :           1 :         return gjs_gi_argument_release_out_array(cx, transfer, &m_type_info,
     898                 :           1 :                                                  size, out_arg);
     899                 :             :     }
     900                 :             : };
     901                 :             : 
     902                 :             : GJS_JSAPI_RETURN_CONVENTION
     903                 :           3 : bool NotIntrospectable::in(JSContext* cx, GjsFunctionCallState* state,
     904                 :             :                            GIArgument*, JS::HandleValue) {
     905                 :           3 :     const char* reason_string = "invalid introspection";
     906                 :             : 
     907   [ -  +  +  -  :           3 :     switch (m_reason) {
          +  -  -  -  -  
                      - ]
     908                 :           0 :         case CALLBACK_OUT:
     909                 :           0 :             reason_string = "callback out-argument";
     910                 :           0 :             break;
     911                 :           1 :         case DESTROY_NOTIFY_NO_CALLBACK:
     912                 :           1 :             reason_string = "DestroyNotify argument with no callback";
     913                 :           1 :             break;
     914                 :           1 :         case DESTROY_NOTIFY_NO_USER_DATA:
     915                 :           1 :             reason_string = "DestroyNotify argument with no user data";
     916                 :           1 :             break;
     917                 :           0 :         case INTERFACE_TRANSFER_CONTAINER:
     918                 :           0 :             reason_string = "type not supported for (transfer container)";
     919                 :           0 :             break;
     920                 :           1 :         case OUT_CALLER_ALLOCATES_NON_STRUCT:
     921                 :           1 :             reason_string = "type not supported for (out caller-allocates)";
     922                 :           1 :             break;
     923                 :           0 :         case UNREGISTERED_BOXED_WITH_TRANSFER:
     924                 :           0 :             reason_string =
     925                 :             :                 "boxed type with transfer not registered as a GType";
     926                 :           0 :             break;
     927                 :           0 :         case UNREGISTERED_UNION:
     928                 :           0 :             reason_string = "union type not registered as a GType";
     929                 :           0 :             break;
     930                 :           0 :         case UNSUPPORTED_TYPE:
     931                 :           0 :             reason_string = "type not supported by introspection";
     932                 :           0 :             break;
     933                 :           0 :         case LAST_REASON:
     934                 :             :             g_assert_not_reached();
     935                 :             :     }
     936                 :             : 
     937                 :           6 :     gjs_throw(cx,
     938                 :             :               "Function %s() cannot be called: argument '%s' with type %s is "
     939                 :             :               "not introspectable because it has a %s",
     940                 :           6 :               state->display_name().get(), m_arg_name,
     941                 :             :               g_type_tag_to_string(g_type_info_get_tag(&m_type_info)),
     942                 :             :               reason_string);
     943                 :           3 :     return false;
     944                 :             : }
     945                 :             : 
     946                 :             : GJS_JSAPI_RETURN_CONVENTION
     947                 :          71 : bool GenericIn::in(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
     948                 :             :                    JS::HandleValue value) {
     949                 :         142 :     return gjs_value_to_gi_argument(cx, value, &m_type_info, m_arg_name,
     950                 :          71 :                                     GJS_ARGUMENT_ARGUMENT, m_transfer, flags(),
     951                 :          71 :                                     arg);
     952                 :             : }
     953                 :             : 
     954                 :             : GJS_JSAPI_RETURN_CONVENTION
     955                 :          17 : bool GenericInOut::in(JSContext* cx, GjsFunctionCallState* state,
     956                 :             :                       GIArgument* arg, JS::HandleValue value) {
     957         [ -  + ]:          17 :     if (!GenericIn::in(cx, state, arg, value))
     958                 :           0 :         return false;
     959                 :             : 
     960                 :          17 :     return set_inout_parameter(state, arg);
     961                 :             : }
     962                 :             : 
     963                 :             : GJS_JSAPI_RETURN_CONVENTION
     964                 :         338 : bool ExplicitArrayIn::in(JSContext* cx, GjsFunctionCallState* state,
     965                 :             :                          GIArgument* arg, JS::HandleValue value) {
     966                 :             :     void* data;
     967                 :             :     size_t length;
     968                 :             : 
     969         [ +  + ]:         338 :     if (m_length_direction != GI_DIRECTION_INOUT &&
     970         [ -  + ]:         323 :         m_length_direction != GI_DIRECTION_IN) {
     971                 :           0 :         gjs_throw(cx, "Using different length argument direction for array %s"
     972                 :             :                   "is not supported for in arrays", m_arg_name);
     973                 :           0 :         return false;
     974                 :             :     }
     975                 :             : 
     976         [ +  + ]:         338 :     if (!gjs_array_to_explicit_array(cx, value, &m_type_info, m_arg_name,
     977                 :         338 :                                      GJS_ARGUMENT_ARGUMENT, m_transfer, flags(),
     978                 :             :                                      &data, &length))
     979                 :           5 :         return false;
     980                 :             : 
     981                 :         333 :     gjs_gi_argument_set_array_length(m_tag, &state->in_cvalue(m_length_pos),
     982                 :             :                                      length);
     983                 :         333 :     gjs_arg_set(arg, data);
     984                 :         333 :     return true;
     985                 :             : }
     986                 :             : 
     987                 :             : GJS_JSAPI_RETURN_CONVENTION
     988                 :          15 : bool ExplicitArrayInOut::in(JSContext* cx, GjsFunctionCallState* state,
     989                 :             :                             GIArgument* arg, JS::HandleValue value) {
     990         [ -  + ]:          15 :     if (!ExplicitArrayIn::in(cx, state, arg, value))
     991                 :           0 :         return false;
     992                 :             : 
     993                 :          15 :     uint8_t length_pos = m_length_pos;
     994                 :          15 :     uint8_t ix = m_arg_pos;
     995                 :             : 
     996         [ +  + ]:          15 :     if (!gjs_arg_get<void*>(arg)) {
     997                 :             :         // Special case where we were given JS null to also pass null for
     998                 :             :         // length, and not a pointer to an integer that derefs to 0.
     999                 :           9 :         gjs_arg_unset<void*>(&state->in_cvalue(length_pos));
    1000                 :           9 :         gjs_arg_unset<int>(&state->out_cvalue(length_pos));
    1001                 :           9 :         gjs_arg_unset<int>(&state->inout_original_cvalue(length_pos));
    1002                 :             : 
    1003                 :           9 :         gjs_arg_unset<void*>(&state->out_cvalue(ix));
    1004                 :           9 :         gjs_arg_unset<void*>(&state->inout_original_cvalue(ix));
    1005                 :             :     } else {
    1006         [ +  - ]:           6 :         if G_LIKELY (m_length_direction == GI_DIRECTION_INOUT) {
    1007                 :           6 :             state->out_cvalue(length_pos) =
    1008                 :           6 :                 state->inout_original_cvalue(length_pos) =
    1009                 :           6 :                     state->in_cvalue(length_pos);
    1010                 :           6 :             gjs_arg_set(&state->in_cvalue(length_pos),
    1011                 :           6 :                         &state->out_cvalue(length_pos));
    1012                 :             :         }
    1013                 :             : 
    1014                 :           6 :         state->out_cvalue(ix) = state->inout_original_cvalue(ix) = *arg;
    1015                 :           6 :         gjs_arg_set(arg, &state->out_cvalue(ix));
    1016                 :             :     }
    1017                 :             : 
    1018                 :          15 :     return true;
    1019                 :             : }
    1020                 :             : 
    1021                 :             : GJS_JSAPI_RETURN_CONVENTION
    1022                 :         249 : bool CallbackIn::in(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
    1023                 :             :                     JS::HandleValue value) {
    1024                 :             :     GjsCallbackTrampoline* trampoline;
    1025                 :             :     void* closure;
    1026                 :             : 
    1027   [ +  +  +  +  :         249 :     if (value.isNull() && m_nullable) {
                   +  + ]
    1028                 :           8 :         closure = nullptr;
    1029                 :           8 :         trampoline = nullptr;
    1030                 :           8 :         m_ffi_closure = nullptr;
    1031                 :             :     } else {
    1032         [ +  + ]:         241 :         if (JS_TypeOfValue(cx, value) != JSTYPE_FUNCTION) {
    1033                 :           2 :             gjs_throw(cx, "Expected function for callback argument %s, got %s",
    1034                 :             :                       m_arg_name, JS::InformalValueTypeName(value));
    1035                 :           2 :             return false;
    1036                 :             :         }
    1037                 :             : 
    1038                 :         239 :         JS::RootedObject callable(cx, &value.toObject());
    1039                 :         239 :         bool is_object_method = !!state->instance_object;
    1040                 :         239 :         trampoline = GjsCallbackTrampoline::create(
    1041                 :         239 :             cx, callable, m_info, m_scope, is_object_method, false);
    1042         [ -  + ]:         239 :         if (!trampoline)
    1043                 :           0 :             return false;
    1044   [ +  +  -  + ]:         239 :         if (m_scope == GI_SCOPE_TYPE_NOTIFIED && is_object_method) {
    1045                 :           0 :             auto* priv = ObjectInstance::for_js(cx, state->instance_object);
    1046         [ #  # ]:           0 :             if (!priv) {
    1047                 :           0 :                 gjs_throw(cx, "Signal connected to wrong type of object");
    1048                 :           0 :                 return false;
    1049                 :             :             }
    1050                 :             : 
    1051         [ #  # ]:           0 :             if (!priv->associate_closure(cx, trampoline))
    1052                 :           0 :                 return false;
    1053                 :             :         }
    1054                 :         239 :         closure = trampoline->closure();
    1055                 :         239 :         m_ffi_closure = trampoline->get_ffi_closure();
    1056         [ +  - ]:         239 :     }
    1057                 :             : 
    1058         [ +  + ]:         247 :     if (has_callback_destroy()) {
    1059                 :          98 :         GDestroyNotify destroy_notify = nullptr;
    1060         [ +  + ]:          98 :         if (trampoline) {
    1061                 :             :             /* Adding another reference and a DestroyNotify that unsets it */
    1062                 :          94 :             g_closure_ref(trampoline);
    1063                 :          94 :             destroy_notify = [](void* data) {
    1064                 :          78 :                 g_assert(data);
    1065                 :          78 :                 g_closure_unref(static_cast<GClosure*>(data));
    1066                 :          78 :             };
    1067                 :             :         }
    1068                 :          98 :         gjs_arg_set(&state->in_cvalue(m_destroy_pos), destroy_notify);
    1069                 :             :     }
    1070         [ +  + ]:         247 :     if (has_callback_closure())
    1071                 :         223 :         gjs_arg_set(&state->in_cvalue(m_closure_pos), trampoline);
    1072                 :             : 
    1073   [ +  +  +  + ]:         247 :     if (trampoline && m_scope == GI_SCOPE_TYPE_ASYNC) {
    1074                 :             :         // Add an extra reference that will be cleared when garbage collecting
    1075                 :             :         // async calls
    1076                 :         113 :         g_closure_ref(trampoline);
    1077                 :             :     }
    1078                 :             : 
    1079                 :             :     bool keep_forever =
    1080         [ +  + ]:         396 :         !has_callback_destroy() && (
    1081                 :             : #if GI_CHECK_VERSION(1, 72, 0)
    1082         [ +  - ]:         149 :                                        m_scope == GI_SCOPE_TYPE_FOREVER ||
    1083                 :             : #endif
    1084         [ +  + ]:         149 :                                        m_scope == GI_SCOPE_TYPE_NOTIFIED);
    1085                 :             : 
    1086   [ +  +  +  + ]:         247 :     if (trampoline && keep_forever) {
    1087                 :           1 :         trampoline->mark_forever();
    1088                 :             :     }
    1089                 :         247 :     gjs_arg_set(arg, closure);
    1090                 :             : 
    1091                 :         247 :     return true;
    1092                 :             : }
    1093                 :             : 
    1094                 :             : GJS_JSAPI_RETURN_CONVENTION
    1095                 :         138 : bool GenericOut::in(JSContext*, GjsFunctionCallState* state, GIArgument* arg,
    1096                 :             :                     JS::HandleValue) {
    1097                 :             :     // Default value in case a broken C function doesn't fill in the pointer
    1098                 :         138 :     return set_out_parameter(state, arg);
    1099                 :             : }
    1100                 :             : 
    1101                 :             : GJS_JSAPI_RETURN_CONVENTION
    1102                 :           9 : bool CallerAllocatesOut::in(JSContext*, GjsFunctionCallState* state,
    1103                 :             :                             GIArgument* arg, JS::HandleValue) {
    1104                 :           9 :     void* blob = g_malloc0(m_allocates_size);
    1105                 :           9 :     gjs_arg_set(arg, blob);
    1106                 :           9 :     gjs_arg_set(&state->out_cvalue(m_arg_pos), blob);
    1107                 :           9 :     return true;
    1108                 :             : }
    1109                 :             : 
    1110                 :             : GJS_JSAPI_RETURN_CONVENTION
    1111                 :           7 : bool NullIn::in(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
    1112                 :             :                 JS::HandleValue) {
    1113                 :           7 :     return handle_nullable(cx, arg, m_arg_name);
    1114                 :             : }
    1115                 :             : 
    1116                 :             : GJS_JSAPI_RETURN_CONVENTION
    1117                 :         227 : bool BooleanIn::in(JSContext*, GjsFunctionCallState*, GIArgument* arg,
    1118                 :             :                    JS::HandleValue value) {
    1119                 :         227 :     gjs_arg_set(arg, JS::ToBoolean(value));
    1120                 :         227 :     return true;
    1121                 :             : }
    1122                 :             : 
    1123                 :             : template <typename T>
    1124                 :       25588 : GJS_JSAPI_RETURN_CONVENTION bool NumericIn<T>::in(JSContext* cx,
    1125                 :             :                                                   GjsFunctionCallState*,
    1126                 :             :                                                   GIArgument* arg,
    1127                 :             :                                                   JS::HandleValue value) {
    1128                 :       25588 :     bool out_of_range = false;
    1129                 :             : 
    1130         [ +  + ]:       25588 :     if (!gjs_arg_set_from_js_value<T>(cx, value, arg, &out_of_range)) {
    1131         [ +  + ]:          33 :         if (out_of_range) {
    1132                 :           8 :             gjs_throw(cx, "Argument %s: value is out of range for %s",
    1133                 :             :                       arg_name(), Gjs::static_type_name<T>());
    1134                 :             :         }
    1135                 :             : 
    1136                 :          33 :         return false;
    1137                 :             :     }
    1138                 :             : 
    1139                 :             :     gjs_debug_marshal(GJS_DEBUG_GFUNCTION, "%s set to value %s (type %s)",
    1140                 :             :                       GjsAutoChar{gjs_argument_display_name(
    1141                 :             :                                       arg_name(), GJS_ARGUMENT_ARGUMENT)}
    1142                 :             :                           .get(),
    1143                 :             :                       std::to_string(gjs_arg_get<T>(arg)).c_str(),
    1144                 :             :                       Gjs::static_type_name<T>());
    1145                 :             : 
    1146                 :       25555 :     return true;
    1147                 :             : }
    1148                 :             : 
    1149                 :             : GJS_JSAPI_RETURN_CONVENTION
    1150                 :           3 : bool UnicharIn::in(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
    1151                 :             :                    JS::HandleValue value) {
    1152         [ -  + ]:           3 :     if (!value.isString())
    1153                 :           0 :         return report_typeof_mismatch(cx, m_arg_name, value,
    1154                 :           0 :                                       ExpectedType::STRING);
    1155                 :             : 
    1156                 :           3 :     return gjs_unichar_from_string(cx, value, &gjs_arg_member<char32_t>(arg));
    1157                 :             : }
    1158                 :             : 
    1159                 :             : GJS_JSAPI_RETURN_CONVENTION
    1160                 :         470 : bool GTypeIn::in(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
    1161                 :             :                  JS::HandleValue value) {
    1162         [ -  + ]:         470 :     if (value.isNull())
    1163                 :           0 :         return report_invalid_null(cx, m_arg_name);
    1164         [ -  + ]:         470 :     if (!value.isObject())
    1165                 :           0 :         return report_typeof_mismatch(cx, m_arg_name, value,
    1166                 :           0 :                                       ExpectedType::OBJECT);
    1167                 :             : 
    1168                 :         470 :     JS::RootedObject gtype_obj(cx, &value.toObject());
    1169                 :         470 :     return gjs_gtype_get_actual_gtype(
    1170                 :         940 :         cx, gtype_obj, &gjs_arg_member<GType, GI_TYPE_TAG_GTYPE>(arg));
    1171                 :         470 : }
    1172                 :             : 
    1173                 :             : // Common code for most types that are pointers on the C side
    1174                 :       11994 : bool Nullable::handle_nullable(JSContext* cx, GIArgument* arg,
    1175                 :             :                                const char* arg_name) {
    1176         [ +  + ]:       11994 :     if (!m_nullable)
    1177                 :           2 :         return report_invalid_null(cx, arg_name);
    1178                 :       11992 :     gjs_arg_unset<void*>(arg);
    1179                 :       11992 :     return true;
    1180                 :             : }
    1181                 :             : 
    1182                 :             : template <GITypeTag TAG>
    1183                 :        4888 : GJS_JSAPI_RETURN_CONVENTION bool StringInTransferNone<TAG>::in(
    1184                 :             :     JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
    1185                 :             :     JS::HandleValue value) {
    1186         [ +  + ]:        4888 :     if (value.isNull())
    1187                 :          30 :         return NullableIn::in(cx, state, arg, value);
    1188                 :             : 
    1189         [ -  + ]:        4858 :     if (!value.isString())
    1190                 :           0 :         return report_typeof_mismatch(cx, m_arg_name, value,
    1191                 :           0 :                                       ExpectedType::STRING);
    1192                 :             : 
    1193                 :             :     if constexpr (TAG == GI_TYPE_TAG_FILENAME) {
    1194                 :         163 :         GjsAutoChar str;
    1195         [ -  + ]:         163 :         if (!gjs_string_to_filename(cx, value, &str))
    1196                 :           0 :             return false;
    1197                 :         163 :         gjs_arg_set(arg, str.release());
    1198                 :         163 :         return true;
    1199                 :         163 :     } else if constexpr (TAG == GI_TYPE_TAG_UTF8) {
    1200                 :        4695 :         JS::UniqueChars str = gjs_string_to_utf8(cx, value);
    1201         [ -  + ]:        4695 :         if (!str)
    1202                 :           0 :             return false;
    1203                 :        9390 :         gjs_arg_set(arg, g_strdup(str.get()));
    1204                 :        4695 :         return true;
    1205                 :        4695 :     } else {
    1206                 :             :         return invalid(cx, G_STRFUNC);
    1207                 :             :     }
    1208                 :             : }
    1209                 :             : 
    1210                 :             : GJS_JSAPI_RETURN_CONVENTION
    1211                 :          22 : bool EnumIn::in(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
    1212                 :             :                 JS::HandleValue value) {
    1213                 :             :     int64_t number;
    1214         [ -  + ]:          22 :     if (!Gjs::js_value_to_c(cx, value, &number))
    1215                 :           0 :         return false;
    1216                 :             : 
    1217                 :             :     // Unpack the values from their uint32_t bitfield. See note in
    1218                 :             :     // Enum::Enum().
    1219                 :             :     int64_t min, max;
    1220         [ +  + ]:          22 :     if (m_unsigned) {
    1221                 :           2 :         min = m_min;
    1222                 :           2 :         max = m_max;
    1223                 :             :     } else {
    1224                 :          20 :         min = static_cast<int32_t>(m_min);
    1225                 :          20 :         max = static_cast<int32_t>(m_max);
    1226                 :             :     }
    1227                 :             : 
    1228   [ +  -  -  + ]:          22 :     if (number > max || number < min) {
    1229                 :           0 :         gjs_throw(cx, "%" PRId64 " is not a valid value for enum argument %s",
    1230                 :             :                   number, m_arg_name);
    1231                 :           0 :         return false;
    1232                 :             :     }
    1233                 :             : 
    1234         [ +  + ]:          22 :     if (m_unsigned)
    1235                 :           2 :         gjs_arg_set<unsigned, GI_TYPE_TAG_INTERFACE>(arg, number);
    1236                 :             :     else
    1237                 :          20 :         gjs_arg_set<int, GI_TYPE_TAG_INTERFACE>(arg, number);
    1238                 :             : 
    1239                 :          22 :     return true;
    1240                 :             : }
    1241                 :             : 
    1242                 :             : GJS_JSAPI_RETURN_CONVENTION
    1243                 :         489 : bool FlagsIn::in(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
    1244                 :             :                  JS::HandleValue value) {
    1245                 :             :     int64_t number;
    1246         [ -  + ]:         489 :     if (!Gjs::js_value_to_c(cx, value, &number))
    1247                 :           0 :         return false;
    1248                 :             : 
    1249         [ -  + ]:         489 :     if ((uint64_t(number) & m_mask) != uint64_t(number)) {
    1250                 :           0 :         gjs_throw(cx,
    1251                 :             :                   "0x%" PRId64 " is not a valid value for flags argument %s",
    1252                 :             :                   number, m_arg_name);
    1253                 :           0 :         return false;
    1254                 :             :     }
    1255                 :             : 
    1256                 :             :     // We cast to unsigned because that's what makes sense, but then we
    1257                 :             :     // put it in the v_int slot because that's what we use to unmarshal
    1258                 :             :     // flags types at the moment.
    1259                 :         489 :     gjs_arg_set<int, GI_TYPE_TAG_INTERFACE>(arg, static_cast<unsigned>(number));
    1260                 :         489 :     return true;
    1261                 :             : }
    1262                 :             : 
    1263                 :             : GJS_JSAPI_RETURN_CONVENTION
    1264                 :           2 : bool ForeignStructInstanceIn::in(JSContext* cx, GjsFunctionCallState*,
    1265                 :             :                                  GIArgument* arg, JS::HandleValue value) {
    1266                 :           2 :     return gjs_struct_foreign_convert_to_gi_argument(
    1267                 :           2 :         cx, value, m_info, m_arg_name, GJS_ARGUMENT_ARGUMENT, m_transfer,
    1268                 :           4 :         flags(), arg);
    1269                 :             : }
    1270                 :             : 
    1271                 :             : GJS_JSAPI_RETURN_CONVENTION
    1272                 :         111 : bool GValueIn::in(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
    1273                 :             :                   JS::HandleValue value) {
    1274         [ +  + ]:         111 :     if (value.isObject()) {
    1275                 :          87 :         JS::RootedObject obj(cx, &value.toObject());
    1276                 :             :         GType gtype;
    1277                 :             : 
    1278         [ -  + ]:          87 :         if (!gjs_gtype_get_actual_gtype(cx, obj, &gtype))
    1279                 :           0 :             return false;
    1280                 :             : 
    1281         [ +  + ]:          87 :         if (gtype == G_TYPE_VALUE) {
    1282                 :          60 :             gjs_arg_set(arg, BoxedBase::to_c_ptr<GValue>(cx, obj));
    1283                 :          60 :             state->ignore_release.insert(arg);
    1284                 :          60 :             return true;
    1285                 :             :         }
    1286         [ +  + ]:          87 :     }
    1287                 :             : 
    1288                 :          51 :     Gjs::AutoGValue gvalue;
    1289                 :             : 
    1290         [ -  + ]:          51 :     if (!gjs_value_to_g_value(cx, value, &gvalue))
    1291                 :           0 :         return false;
    1292                 :             : 
    1293                 :          51 :     gjs_arg_set(arg, g_boxed_copy(G_TYPE_VALUE, &gvalue));
    1294                 :             : 
    1295                 :          51 :     return true;
    1296                 :          51 : }
    1297                 :             : 
    1298                 :             : GJS_JSAPI_RETURN_CONVENTION
    1299                 :       58813 : bool BoxedInTransferNone::in(JSContext* cx, GjsFunctionCallState* state,
    1300                 :             :                              GIArgument* arg, JS::HandleValue value) {
    1301         [ +  + ]:       58813 :     if (value.isNull())
    1302                 :       11677 :         return NullableIn::in(cx, state, arg, value);
    1303                 :             : 
    1304                 :       47136 :     GType gtype = RegisteredType::gtype();
    1305                 :             : 
    1306         [ -  + ]:       47136 :     if (!value.isObject())
    1307                 :           0 :         return report_gtype_mismatch(cx, m_arg_name, value, gtype);
    1308                 :             : 
    1309                 :       47136 :     JS::RootedObject object(cx, &value.toObject());
    1310         [ +  + ]:       47136 :     if (gtype == G_TYPE_ERROR) {
    1311                 :          12 :         return ErrorBase::transfer_to_gi_argument(cx, object, arg,
    1312                 :          12 :                                                   GI_DIRECTION_IN, m_transfer);
    1313                 :             :     }
    1314                 :             : 
    1315                 :       94260 :     return BoxedBase::transfer_to_gi_argument(cx, object, arg, GI_DIRECTION_IN,
    1316                 :       94260 :                                               m_transfer, gtype, info());
    1317                 :       47136 : }
    1318                 :             : 
    1319                 :             : // Unions include ClutterEvent and GdkEvent, which occur fairly often in an
    1320                 :             : // interactive application, so they're worth a special case in a different
    1321                 :             : // virtual function.
    1322                 :             : GJS_JSAPI_RETURN_CONVENTION
    1323                 :           2 : bool UnionIn::in(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
    1324                 :             :                  JS::HandleValue value) {
    1325         [ -  + ]:           2 :     if (value.isNull())
    1326                 :           0 :         return NullableIn::in(cx, state, arg, value);
    1327                 :             : 
    1328                 :           2 :     GType gtype = RegisteredType::gtype();
    1329                 :             : 
    1330         [ -  + ]:           2 :     if (!value.isObject())
    1331                 :           0 :         return report_gtype_mismatch(cx, m_arg_name, value, gtype);
    1332                 :             : 
    1333                 :           2 :     JS::RootedObject object(cx, &value.toObject());
    1334                 :           2 :     return UnionBase::transfer_to_gi_argument(cx, object, arg, GI_DIRECTION_IN,
    1335                 :           4 :                                               m_transfer, gtype);
    1336                 :           2 : }
    1337                 :             : 
    1338                 :             : GJS_JSAPI_RETURN_CONVENTION
    1339                 :       11553 : bool GClosureInTransferNone::in(JSContext* cx, GjsFunctionCallState* state,
    1340                 :             :                                 GIArgument* arg, JS::HandleValue value) {
    1341         [ -  + ]:       11553 :     if (value.isNull())
    1342                 :           0 :         return NullableIn::in(cx, state, arg, value);
    1343                 :             : 
    1344         [ -  + ]:       11553 :     if (!(JS_TypeOfValue(cx, value) == JSTYPE_FUNCTION))
    1345                 :           0 :         return report_typeof_mismatch(cx, m_arg_name, value,
    1346                 :           0 :                                       ExpectedType::FUNCTION);
    1347                 :             : 
    1348                 :       11553 :     JS::RootedObject callable(cx, &value.toObject());
    1349                 :       11553 :     GClosure* closure = Gjs::Closure::create_marshaled(cx, callable, "boxed");
    1350                 :       11553 :     gjs_arg_set(arg, closure);
    1351                 :       11553 :     g_closure_ref(closure);
    1352                 :       11553 :     g_closure_sink(closure);
    1353                 :             : 
    1354                 :       11553 :     return true;
    1355                 :       11553 : }
    1356                 :             : 
    1357                 :             : GJS_JSAPI_RETURN_CONVENTION
    1358                 :          71 : bool GBytesIn::in(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
    1359                 :             :                   JS::HandleValue value) {
    1360         [ -  + ]:          71 :     if (value.isNull())
    1361                 :           0 :         return NullableIn::in(cx, state, arg, value);
    1362                 :             : 
    1363         [ -  + ]:          71 :     if (!value.isObject())
    1364                 :           0 :         return report_gtype_mismatch(cx, m_arg_name, value, G_TYPE_BYTES);
    1365                 :             : 
    1366                 :          71 :     JS::RootedObject object(cx, &value.toObject());
    1367         [ +  + ]:          71 :     if (JS_IsUint8Array(object)) {
    1368                 :          21 :         state->ignore_release.insert(arg);
    1369                 :          21 :         gjs_arg_set(arg, gjs_byte_array_get_bytes(object));
    1370                 :          21 :         return true;
    1371                 :             :     }
    1372                 :             : 
    1373                 :             :     // The bytearray path is taking an extra ref irrespective of transfer
    1374                 :             :     // ownership, so we need to do the same here.
    1375                 :         100 :     return BoxedBase::transfer_to_gi_argument(
    1376                 :          50 :         cx, object, arg, GI_DIRECTION_IN, GI_TRANSFER_EVERYTHING, G_TYPE_BYTES);
    1377                 :          71 : }
    1378                 :             : 
    1379                 :             : GJS_JSAPI_RETURN_CONVENTION
    1380                 :          35 : bool GBytesIn::release(JSContext* cx, GjsFunctionCallState* state,
    1381                 :             :                        GIArgument* in_arg, GIArgument* out_arg) {
    1382         [ -  + ]:          35 :     if (state->ignore_release.erase(in_arg))
    1383                 :           0 :         return BoxedIn::release(cx, state, in_arg, out_arg);
    1384                 :             : 
    1385                 :          35 :     return BoxedInTransferNone::release(cx, state, in_arg, out_arg);
    1386                 :             : }
    1387                 :             : 
    1388                 :             : GJS_JSAPI_RETURN_CONVENTION
    1389                 :           4 : bool InterfaceIn::in(JSContext* cx, GjsFunctionCallState* state,
    1390                 :             :                      GIArgument* arg, JS::HandleValue value) {
    1391         [ -  + ]:           4 :     if (value.isNull())
    1392                 :           0 :         return NullableIn::in(cx, state, arg, value);
    1393                 :             : 
    1394                 :           4 :     GType gtype = RegisteredType::gtype();
    1395                 :             : 
    1396         [ -  + ]:           4 :     if (!value.isObject())
    1397                 :           0 :         return report_gtype_mismatch(cx, m_arg_name, value, gtype);
    1398                 :             : 
    1399                 :           4 :     JS::RootedObject object(cx, &value.toObject());
    1400                 :             : 
    1401                 :             :     // Could be a GObject interface that's missing a prerequisite,
    1402                 :             :     // or could be a fundamental
    1403         [ +  - ]:           4 :     if (ObjectBase::typecheck(cx, object, nullptr, gtype,
    1404                 :             :                               GjsTypecheckNoThrow())) {
    1405                 :           8 :         return ObjectBase::transfer_to_gi_argument(
    1406                 :           8 :             cx, object, arg, GI_DIRECTION_IN, m_transfer, gtype);
    1407                 :             :     }
    1408                 :             : 
    1409                 :             :     // If this typecheck fails, then it's neither an object nor a
    1410                 :             :     // fundamental
    1411                 :           0 :     return FundamentalBase::transfer_to_gi_argument(
    1412                 :           0 :         cx, object, arg, GI_DIRECTION_IN, m_transfer, gtype);
    1413                 :           4 : }
    1414                 :             : 
    1415                 :             : GJS_JSAPI_RETURN_CONVENTION
    1416                 :        2209 : bool ObjectIn::in(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
    1417                 :             :                   JS::HandleValue value) {
    1418         [ +  + ]:        2209 :     if (value.isNull())
    1419                 :         280 :         return NullableIn::in(cx, state, arg, value);
    1420                 :             : 
    1421                 :        1929 :     GType gtype = RegisteredType::gtype();
    1422                 :             : 
    1423         [ -  + ]:        1929 :     if (!value.isObject())
    1424                 :           0 :         return report_gtype_mismatch(cx, m_arg_name, value, gtype);
    1425                 :             : 
    1426                 :        1929 :     JS::RootedObject object(cx, &value.toObject());
    1427                 :        1929 :     return ObjectBase::transfer_to_gi_argument(cx, object, arg, GI_DIRECTION_IN,
    1428                 :        3858 :                                                m_transfer, gtype);
    1429                 :        1929 : }
    1430                 :             : 
    1431                 :             : GJS_JSAPI_RETURN_CONVENTION
    1432                 :           3 : bool FundamentalIn::in(JSContext* cx, GjsFunctionCallState* state,
    1433                 :             :                        GIArgument* arg, JS::HandleValue value) {
    1434         [ -  + ]:           3 :     if (value.isNull())
    1435                 :           0 :         return NullableIn::in(cx, state, arg, value);
    1436                 :             : 
    1437                 :           3 :     GType gtype = RegisteredType::gtype();
    1438                 :             : 
    1439         [ -  + ]:           3 :     if (!value.isObject())
    1440                 :           0 :         return report_gtype_mismatch(cx, m_arg_name, value, gtype);
    1441                 :             : 
    1442                 :           3 :     JS::RootedObject object(cx, &value.toObject());
    1443                 :           3 :     return FundamentalBase::transfer_to_gi_argument(
    1444                 :           6 :         cx, object, arg, GI_DIRECTION_IN, m_transfer, gtype);
    1445                 :           3 : }
    1446                 :             : 
    1447                 :             : GJS_JSAPI_RETURN_CONVENTION
    1448                 :          87 : bool GTypeStructInstanceIn::in(JSContext* cx, GjsFunctionCallState*,
    1449                 :             :                                GIArgument* arg, JS::HandleValue value) {
    1450                 :             :     // Instance parameter is never nullable
    1451         [ -  + ]:          87 :     if (!value.isObject())
    1452                 :           0 :         return report_typeof_mismatch(cx, m_arg_name, value,
    1453                 :           0 :                                       ExpectedType::OBJECT);
    1454                 :             : 
    1455                 :          87 :     JS::RootedObject obj(cx, &value.toObject());
    1456                 :             :     GType actual_gtype;
    1457         [ -  + ]:          87 :     if (!gjs_gtype_get_actual_gtype(cx, obj, &actual_gtype))
    1458                 :           0 :         return false;
    1459                 :             : 
    1460         [ -  + ]:          87 :     if (actual_gtype == G_TYPE_NONE) {
    1461                 :           0 :         gjs_throw(cx, "Invalid GType class passed for instance parameter");
    1462                 :           0 :         return false;
    1463                 :             :     }
    1464                 :             : 
    1465                 :             :     // We use peek here to simplify reference counting (we just ignore transfer
    1466                 :             :     // annotation, as GType classes are never really freed.) We know that the
    1467                 :             :     // GType class is referenced at least once when the JS constructor is
    1468                 :             :     // initialized.
    1469   [ +  -  -  +  :          87 :     if (g_type_is_a(actual_gtype, G_TYPE_INTERFACE))
                   -  + ]
    1470                 :           0 :         gjs_arg_set(arg, g_type_default_interface_peek(actual_gtype));
    1471                 :             :     else
    1472                 :          87 :         gjs_arg_set(arg, g_type_class_peek(actual_gtype));
    1473                 :             : 
    1474                 :          87 :     return true;
    1475                 :          87 : }
    1476                 :             : 
    1477                 :             : GJS_JSAPI_RETURN_CONVENTION
    1478                 :         161 : bool ParamInstanceIn::in(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
    1479                 :             :                          JS::HandleValue value) {
    1480                 :             :     // Instance parameter is never nullable
    1481         [ -  + ]:         161 :     if (!value.isObject())
    1482                 :           0 :         return report_typeof_mismatch(cx, m_arg_name, value,
    1483                 :           0 :                                       ExpectedType::OBJECT);
    1484                 :             : 
    1485                 :         161 :     JS::RootedObject obj(cx, &value.toObject());
    1486         [ -  + ]:         161 :     if (!gjs_typecheck_param(cx, obj, G_TYPE_PARAM, true))
    1487                 :           0 :         return false;
    1488                 :         161 :     gjs_arg_set(arg, gjs_g_param_from_param(cx, obj));
    1489                 :             : 
    1490         [ -  + ]:         161 :     if (m_transfer == GI_TRANSFER_EVERYTHING)
    1491                 :           0 :         g_param_spec_ref(gjs_arg_get<GParamSpec*>(arg));
    1492                 :             : 
    1493                 :         161 :     return true;
    1494                 :         161 : }
    1495                 :             : 
    1496                 :             : GJS_JSAPI_RETURN_CONVENTION
    1497                 :       21412 : bool GenericInOut::out(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
    1498                 :             :                        JS::MutableHandleValue value) {
    1499                 :       21412 :     return gjs_value_from_gi_argument(cx, value, &m_type_info, arg, true);
    1500                 :             : }
    1501                 :             : 
    1502                 :             : GJS_JSAPI_RETURN_CONVENTION
    1503                 :          36 : bool ExplicitArrayInOut::out(JSContext* cx, GjsFunctionCallState* state,
    1504                 :             :                              GIArgument* arg, JS::MutableHandleValue value) {
    1505                 :             :     GIArgument* length_arg;
    1506                 :             : 
    1507         [ +  - ]:          36 :     if (m_length_direction != GI_DIRECTION_IN)
    1508                 :          36 :         length_arg = &(state->out_cvalue(m_length_pos));
    1509                 :             :     else
    1510                 :           0 :         length_arg = &(state->in_cvalue(m_length_pos));
    1511                 :             : 
    1512                 :          36 :     size_t length = gjs_gi_argument_get_array_length(m_tag, length_arg);
    1513                 :             : 
    1514                 :          36 :     return gjs_value_from_explicit_array(cx, value, &m_type_info, m_transfer,
    1515                 :          36 :                                          arg, length);
    1516                 :             : }
    1517                 :             : 
    1518                 :             : GJS_JSAPI_RETURN_CONVENTION
    1519                 :          35 : bool GenericIn::release(JSContext* cx, GjsFunctionCallState* state,
    1520                 :             :                         GIArgument* in_arg, GIArgument*) {
    1521                 :             :     GITransfer transfer =
    1522         [ +  - ]:          35 :         state->call_completed() ? m_transfer : GI_TRANSFER_NOTHING;
    1523                 :          35 :     return gjs_gi_argument_release_in_arg(cx, transfer, &m_type_info, in_arg);
    1524                 :             : }
    1525                 :             : 
    1526                 :             : GJS_JSAPI_RETURN_CONVENTION
    1527                 :       21386 : bool GenericOut::release(JSContext* cx, GjsFunctionCallState*,
    1528                 :             :                          GIArgument* in_arg [[maybe_unused]],
    1529                 :             :                          GIArgument* out_arg) {
    1530                 :       21386 :     return gjs_gi_argument_release(cx, m_transfer, &m_type_info, out_arg);
    1531                 :             : }
    1532                 :             : 
    1533                 :             : GJS_JSAPI_RETURN_CONVENTION
    1534                 :          14 : bool GenericInOut::release(JSContext* cx, GjsFunctionCallState* state,
    1535                 :             :                            GIArgument*, GIArgument* out_arg) {
    1536                 :             :     // For inout, transfer refers to what we get back from the function; for
    1537                 :             :     // the temporary C value we allocated, clearly we're responsible for
    1538                 :             :     // freeing it.
    1539                 :             : 
    1540                 :          14 :     GIArgument* original_out_arg = &state->inout_original_cvalue(m_arg_pos);
    1541         [ -  + ]:          14 :     if (!gjs_gi_argument_release_in_arg(cx, GI_TRANSFER_NOTHING, &m_type_info,
    1542                 :             :                                         original_out_arg))
    1543                 :           0 :         return false;
    1544                 :             : 
    1545                 :          14 :     return gjs_gi_argument_release(cx, m_transfer, &m_type_info, out_arg);
    1546                 :             : }
    1547                 :             : 
    1548                 :             : GJS_JSAPI_RETURN_CONVENTION
    1549                 :          21 : bool ExplicitArrayOut::release(JSContext* cx, GjsFunctionCallState* state,
    1550                 :             :                                GIArgument* in_arg [[maybe_unused]],
    1551                 :             :                                GIArgument* out_arg) {
    1552                 :          21 :     GIArgument* length_arg = &state->out_cvalue(m_length_pos);
    1553                 :          21 :     size_t length = gjs_gi_argument_get_array_length(m_tag, length_arg);
    1554                 :             : 
    1555                 :          21 :     return gjs_gi_argument_release_out_array(cx, m_transfer, &m_type_info,
    1556                 :          21 :                                              length, out_arg);
    1557                 :             : }
    1558                 :             : 
    1559                 :             : GJS_JSAPI_RETURN_CONVENTION
    1560                 :         318 : bool ExplicitArrayIn::release(JSContext* cx, GjsFunctionCallState* state,
    1561                 :             :                               GIArgument* in_arg,
    1562                 :             :                               GIArgument* out_arg [[maybe_unused]]) {
    1563                 :         318 :     GIArgument* length_arg = &state->in_cvalue(m_length_pos);
    1564                 :         318 :     size_t length = gjs_gi_argument_get_array_length(m_tag, length_arg);
    1565                 :             : 
    1566                 :             :     GITransfer transfer =
    1567         [ +  + ]:         318 :         state->call_completed() ? m_transfer : GI_TRANSFER_NOTHING;
    1568                 :             : 
    1569                 :         318 :     return gjs_gi_argument_release_in_array(cx, transfer, &m_type_info, length,
    1570                 :         318 :                                             in_arg);
    1571                 :             : }
    1572                 :             : 
    1573                 :             : GJS_JSAPI_RETURN_CONVENTION
    1574                 :          15 : bool ExplicitArrayInOut::release(JSContext* cx, GjsFunctionCallState* state,
    1575                 :             :                                  GIArgument* in_arg [[maybe_unused]],
    1576                 :             :                                  GIArgument* out_arg) {
    1577                 :          15 :     GIArgument* length_arg = &state->out_cvalue(m_length_pos);
    1578                 :          15 :     size_t length = gjs_gi_argument_get_array_length(m_tag, length_arg);
    1579                 :             : 
    1580                 :             :     // For inout, transfer refers to what we get back from the function; for
    1581                 :             :     // the temporary C value we allocated, clearly we're responsible for
    1582                 :             :     // freeing it.
    1583                 :             : 
    1584                 :          15 :     GIArgument* original_out_arg = &state->inout_original_cvalue(m_arg_pos);
    1585                 :             :     // Due to https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/192
    1586                 :             :     // Here we've to guess what to do, but in general is "better" to leak than
    1587                 :             :     // crash, so let's assume that in/out transfer is matching.
    1588         [ +  + ]:          15 :     if (gjs_arg_get<void*>(original_out_arg) != gjs_arg_get<void*>(out_arg)) {
    1589                 :             :         GITransfer transfer =
    1590         [ +  - ]:           4 :             state->call_completed() ? m_transfer : GI_TRANSFER_NOTHING;
    1591         [ -  + ]:           4 :         if (!gjs_gi_argument_release_in_array(cx, transfer, &m_type_info,
    1592                 :             :                                               length, original_out_arg))
    1593                 :           0 :             return false;
    1594                 :             :     }
    1595                 :             : 
    1596                 :             :     GITransfer transfer =
    1597         [ +  - ]:          15 :         state->call_completed() ? m_transfer : GI_TRANSFER_NOTHING;
    1598                 :          15 :     return gjs_gi_argument_release_out_array(cx, transfer, &m_type_info, length,
    1599                 :          15 :                                              out_arg);
    1600                 :             : }
    1601                 :             : 
    1602                 :             : GJS_JSAPI_RETURN_CONVENTION
    1603                 :           6 : bool CallerAllocatesOut::release(JSContext*, GjsFunctionCallState*,
    1604                 :             :                                  GIArgument* in_arg,
    1605                 :             :                                  GIArgument* out_arg [[maybe_unused]]) {
    1606                 :           6 :     g_free(gjs_arg_steal<void*>(in_arg));
    1607                 :           6 :     return true;
    1608                 :             : }
    1609                 :             : 
    1610                 :             : GJS_JSAPI_RETURN_CONVENTION
    1611                 :           3 : bool BoxedCallerAllocatesOut::release(JSContext*, GjsFunctionCallState*,
    1612                 :             :                                       GIArgument* in_arg, GIArgument*) {
    1613                 :           3 :     g_boxed_free(m_gtype, gjs_arg_steal<void*>(in_arg));
    1614                 :           3 :     return true;
    1615                 :             : }
    1616                 :             : 
    1617                 :             : GJS_JSAPI_RETURN_CONVENTION
    1618                 :         247 : bool CallbackIn::release(JSContext*, GjsFunctionCallState*, GIArgument* in_arg,
    1619                 :             :                          GIArgument* out_arg [[maybe_unused]]) {
    1620                 :         247 :     ffi_closure *closure = m_ffi_closure;
    1621         [ +  + ]:         247 :     if (!closure)
    1622                 :           8 :         return true;
    1623                 :             : 
    1624                 :         239 :     g_closure_unref(static_cast<GClosure*>(closure->user_data));
    1625                 :             :     // CallbackTrampolines are refcounted because for notified/async closures
    1626                 :             :     // it is possible to destroy it while in call, and therefore we cannot
    1627                 :             :     // check its scope at this point
    1628                 :         239 :     gjs_arg_unset<void*>(in_arg);
    1629                 :         239 :     return true;
    1630                 :             : }
    1631                 :             : 
    1632                 :             : template <GITypeTag TAG>
    1633                 :        4887 : GJS_JSAPI_RETURN_CONVENTION bool StringInTransferNone<TAG>::release(
    1634                 :             :     JSContext*, GjsFunctionCallState*, GIArgument* in_arg,
    1635                 :             :     GIArgument* out_arg [[maybe_unused]]) {
    1636                 :        4887 :     g_free(gjs_arg_get<void*>(in_arg));
    1637                 :        4887 :     return true;
    1638                 :             : }
    1639                 :             : 
    1640                 :             : GJS_JSAPI_RETURN_CONVENTION
    1641                 :           2 : bool ForeignStructIn::release(JSContext* cx, GjsFunctionCallState* state,
    1642                 :             :                               GIArgument* in_arg,
    1643                 :             :                               GIArgument* out_arg [[maybe_unused]]) {
    1644                 :             :     GITransfer transfer =
    1645         [ +  - ]:           2 :         state->call_completed() ? m_transfer : GI_TRANSFER_NOTHING;
    1646                 :             : 
    1647         [ +  - ]:           2 :     if (transfer == GI_TRANSFER_NOTHING)
    1648                 :           2 :         return gjs_struct_foreign_release_gi_argument(cx, m_transfer, m_info,
    1649                 :           2 :                                                       in_arg);
    1650                 :             : 
    1651                 :           0 :     return true;
    1652                 :             : }
    1653                 :             : 
    1654                 :             : GJS_JSAPI_RETURN_CONVENTION
    1655                 :       11675 : bool BoxedInTransferNone::release(JSContext*, GjsFunctionCallState*,
    1656                 :             :                                   GIArgument* in_arg,
    1657                 :             :                                   GIArgument* out_arg [[maybe_unused]]) {
    1658                 :       11675 :     GType gtype = RegisteredType::gtype();
    1659                 :       11675 :     g_assert(g_type_is_a(gtype, G_TYPE_BOXED));
    1660                 :             : 
    1661         [ -  + ]:       11675 :     if (!gjs_arg_get<void*>(in_arg))
    1662                 :           0 :         return true;
    1663                 :             : 
    1664                 :       11675 :     g_boxed_free(gtype, gjs_arg_get<void*>(in_arg));
    1665                 :       11675 :     return true;
    1666                 :             : }
    1667                 :             : 
    1668                 :             : GJS_JSAPI_RETURN_CONVENTION
    1669                 :         111 : bool GValueInTransferNone::release(JSContext* cx, GjsFunctionCallState* state,
    1670                 :             :                                    GIArgument* in_arg, GIArgument* out_arg) {
    1671         [ +  + ]:         111 :     if (state->ignore_release.erase(in_arg))
    1672                 :          60 :         return true;
    1673                 :             : 
    1674                 :          51 :     return BoxedInTransferNone::release(cx, state, in_arg, out_arg);
    1675                 :             : }
    1676                 :             : 
    1677                 :             : }  // namespace Arg
    1678                 :             : 
    1679                 :           0 : bool Argument::invalid(JSContext* cx, const char* func) const {
    1680         [ #  # ]:           0 :     gjs_throw(cx, "%s not implemented", func ? func : "Function");
    1681                 :           0 :     return false;
    1682                 :             : }
    1683                 :             : 
    1684                 :           0 : bool Argument::in(JSContext* cx, GjsFunctionCallState*, GIArgument*,
    1685                 :             :                   JS::HandleValue) {
    1686                 :           0 :     return invalid(cx, G_STRFUNC);
    1687                 :             : }
    1688                 :             : 
    1689                 :           0 : bool Argument::out(JSContext* cx, GjsFunctionCallState*, GIArgument*,
    1690                 :             :                    JS::MutableHandleValue) {
    1691                 :           0 :     return invalid(cx, G_STRFUNC);
    1692                 :             : }
    1693                 :             : 
    1694                 :           0 : bool Argument::release(JSContext*, GjsFunctionCallState*, GIArgument*,
    1695                 :             :                        GIArgument*) {
    1696                 :           0 :     return true;
    1697                 :             : }
    1698                 :             : 
    1699                 :             : // This is a trick to print out the sizes of the structs at compile time, in
    1700                 :             : // an error message:
    1701                 :             : // template <int s> struct Measure;
    1702                 :             : // Measure<sizeof(Arg::)> arg_size;
    1703                 :             : 
    1704                 :             : #ifdef GJS_DO_ARGUMENTS_SIZE_CHECK
    1705                 :             : template <typename T>
    1706                 :             : constexpr size_t argument_maximum_size() {
    1707                 :             :     if constexpr (std::is_same_v<T, Arg::NumericIn<int>>)
    1708                 :             :         return 24;
    1709                 :             :     if constexpr (std::is_same_v<T, Arg::ObjectIn> ||
    1710                 :             :                   std::is_same_v<T, Arg::BoxedIn>)
    1711                 :             :         return 40;
    1712                 :             :     else
    1713                 :             :         return 120;
    1714                 :             : }
    1715                 :             : #endif
    1716                 :             : 
    1717                 :             : template <typename T, Arg::Kind ArgKind, typename... Args>
    1718                 :       32917 : GjsAutoCppPointer<T> Argument::make(uint8_t index, const char* name,
    1719                 :             :                                     GITypeInfo* type_info, GITransfer transfer,
    1720                 :             :                                     GjsArgumentFlags flags, Args&&... args) {
    1721                 :             : #ifdef GJS_DO_ARGUMENTS_SIZE_CHECK
    1722                 :             :     static_assert(
    1723                 :             :         sizeof(T) <= argument_maximum_size<T>(),
    1724                 :             :         "Think very hard before increasing the size of Gjs::Arguments. "
    1725                 :             :         "One is allocated for every argument to every introspected function.");
    1726                 :             : #endif
    1727                 :       32917 :     auto arg = new T(args...);
    1728                 :             : 
    1729                 :             :     if constexpr (ArgKind == Arg::Kind::INSTANCE) {
    1730                 :        3448 :         g_assert(index == Argument::ABSENT &&
    1731                 :             :                  "index was ignored in INSTANCE parameter");
    1732                 :        3448 :         g_assert(name == nullptr && "name was ignored in INSTANCE parameter");
    1733                 :        3448 :         arg->set_instance_parameter();
    1734                 :             :     } else if constexpr (ArgKind == Arg::Kind::RETURN_VALUE) {
    1735                 :        8621 :         g_assert(index == Argument::ABSENT &&
    1736                 :             :                  "index was ignored in RETURN_VALUE parameter");
    1737                 :        8621 :         g_assert(name == nullptr &&
    1738                 :             :                  "name was ignored in RETURN_VALUE parameter");
    1739                 :        8621 :         arg->set_return_value();
    1740                 :             :     } else {
    1741                 :             :         if constexpr (std::is_base_of_v<Arg::Positioned, T>)
    1742                 :        1757 :             arg->set_arg_pos(index);
    1743                 :       20848 :         arg->m_arg_name = name;
    1744                 :             :     }
    1745                 :             : 
    1746                 :       32917 :     arg->m_skip_in = (flags & GjsArgumentFlags::SKIP_IN);
    1747                 :       32917 :     arg->m_skip_out = (flags & GjsArgumentFlags::SKIP_OUT);
    1748                 :             : 
    1749                 :             :     if constexpr (std::is_base_of_v<Arg::Nullable, T>)
    1750                 :       17802 :         arg->m_nullable = (flags & GjsArgumentFlags::MAY_BE_NULL);
    1751                 :             : 
    1752                 :             :     if constexpr (std::is_base_of_v<Arg::Transferable, T>)
    1753                 :       13530 :         arg->m_transfer = transfer;
    1754                 :             : 
    1755                 :             :     if constexpr (std::is_base_of_v<Arg::TypeInfo, T> &&
    1756                 :             :                   ArgKind != Arg::Kind::INSTANCE) {
    1757                 :        7001 :         arg->m_type_info = std::move(*type_info);
    1758                 :             :     }
    1759                 :             : 
    1760                 :       32917 :     return arg;
    1761                 :             : }
    1762                 :             : 
    1763                 :       10918 : bool ArgsCache::initialize(JSContext* cx, GICallableInfo* callable) {
    1764         [ -  + ]:       10918 :     if (!callable) {
    1765                 :           0 :         gjs_throw(cx, "Invalid callable provided");
    1766                 :           0 :         return false;
    1767                 :             :     }
    1768                 :             : 
    1769         [ -  + ]:       10918 :     if (m_args) {
    1770                 :           0 :         gjs_throw(cx, "Arguments cache already initialized!");
    1771                 :           0 :         return false;
    1772                 :             :     }
    1773                 :             : 
    1774                 :             :     GITypeInfo type_info;
    1775                 :       10918 :     g_callable_info_load_return_type(callable, &type_info);
    1776                 :             : 
    1777   [ +  +  +  + ]:       13467 :     m_has_return = g_type_info_get_tag(&type_info) != GI_TYPE_TAG_VOID ||
    1778                 :        2549 :                    g_type_info_is_pointer(&type_info);
    1779                 :       10918 :     m_is_method = !!g_callable_info_is_method(callable);
    1780                 :             : 
    1781                 :       10918 :     int size = g_callable_info_get_n_args(callable);
    1782         [ +  + ]:       10918 :     size += (m_is_method ? 1 : 0);
    1783         [ +  + ]:       10918 :     size += (m_has_return ? 1 : 0);
    1784                 :             : 
    1785         [ -  + ]:       10918 :     if (size > Argument::MAX_ARGS) {
    1786                 :           0 :         gjs_throw(cx,
    1787                 :             :                   "Too many arguments, only %u are supported, while %d are "
    1788                 :             :                   "provided!",
    1789                 :             :                   Argument::MAX_ARGS, size);
    1790                 :           0 :         return false;
    1791                 :             :     }
    1792                 :             : 
    1793   [ +  -  +  + ]:       43665 :     m_args = new ArgumentPtr[size]{};
    1794                 :       10918 :     return true;
    1795                 :             : }
    1796                 :             : 
    1797                 :             : template <typename T, Arg::Kind ArgKind, typename... Args>
    1798                 :       32917 : constexpr T* ArgsCache::set_argument(uint8_t index, const char* name,
    1799                 :             :                                      GITypeInfo* type_info, GITransfer transfer,
    1800                 :             :                                      GjsArgumentFlags flags, Args&&... args) {
    1801                 :       32917 :     GjsAutoCppPointer<T> arg = Argument::make<T, ArgKind>(
    1802                 :             :         index, name, type_info, transfer, flags, args...);
    1803                 :       32917 :     arg_get<ArgKind>(index) = arg.release();
    1804                 :       32917 :     return static_cast<T*>(arg_get<ArgKind>(index).get());
    1805                 :       32917 : }
    1806                 :             : 
    1807                 :             : template <typename T, Arg::Kind ArgKind, typename... Args>
    1808                 :        2233 : constexpr T* ArgsCache::set_argument(uint8_t index, const char* name,
    1809                 :             :                                      GITransfer transfer,
    1810                 :             :                                      GjsArgumentFlags flags, Args&&... args) {
    1811                 :        2233 :     return set_argument<T, ArgKind>(index, name, nullptr, transfer, flags,
    1812                 :        2233 :                                     args...);
    1813                 :             : }
    1814                 :             : 
    1815                 :             : template <typename T, Arg::Kind ArgKind, typename... Args>
    1816                 :             : constexpr T* ArgsCache::set_argument_auto(Args&&... args) {
    1817                 :             :     return set_argument<T, ArgKind>(std::forward<Args>(args)...);
    1818                 :             : }
    1819                 :             : 
    1820                 :             : template <typename T, Arg::Kind ArgKind, typename Tuple, typename... Args>
    1821                 :       21903 : constexpr T* ArgsCache::set_argument_auto(Tuple&& tuple, Args&&... args) {
    1822                 :             :     // TODO(3v1n0): Would be nice to have a simple way to check we're handling a
    1823                 :             :     // tuple
    1824                 :       21903 :     return std::apply(
    1825                 :       65709 :         [&](auto&&... largs) {
    1826                 :             :             return set_argument<T, ArgKind>(largs...,
    1827                 :       21903 :                                             std::forward<Args>(args)...);
    1828                 :             :         },
    1829                 :       21903 :         tuple);
    1830                 :             : }
    1831                 :             : 
    1832                 :             : template <typename T>
    1833                 :        8621 : constexpr T* ArgsCache::set_return(GITypeInfo* type_info, GITransfer transfer,
    1834                 :             :                                    GjsArgumentFlags flags) {
    1835                 :        8621 :     return set_argument<T, Arg::Kind::RETURN_VALUE>(Argument::ABSENT, nullptr,
    1836                 :        8621 :                                                     type_info, transfer, flags);
    1837                 :             : }
    1838                 :             : 
    1839                 :             : template <typename T>
    1840                 :         584 : constexpr T* ArgsCache::set_instance(GITransfer transfer,
    1841                 :             :                                      GjsArgumentFlags flags) {
    1842                 :         584 :     return set_argument<T, Arg::Kind::INSTANCE>(Argument::ABSENT, nullptr,
    1843                 :         584 :                                                 transfer, flags);
    1844                 :             : }
    1845                 :             : 
    1846                 :       35478 : GType ArgsCache::instance_type() const {
    1847         [ -  + ]:       35478 :     if (!m_is_method)
    1848                 :           0 :         return G_TYPE_NONE;
    1849                 :             : 
    1850                 :       35478 :     return instance()->as_instance()->gtype();
    1851                 :             : }
    1852                 :             : 
    1853                 :       64405 : GITypeTag ArgsCache::return_tag() const {
    1854                 :       64405 :     Argument* rval = return_value();
    1855         [ +  + ]:       64405 :     if (!rval)
    1856                 :       28753 :         return GI_TYPE_TAG_VOID;
    1857                 :             : 
    1858                 :       35652 :     return rval->return_tag();
    1859                 :             : }
    1860                 :             : 
    1861                 :       64405 : GITypeInfo* ArgsCache::return_type() const {
    1862                 :       64405 :     Argument* rval = return_value();
    1863         [ +  + ]:       64405 :     if (!rval)
    1864                 :       28753 :         return nullptr;
    1865                 :             : 
    1866                 :       35652 :     return const_cast<GITypeInfo*>(rval->return_type());
    1867                 :             : }
    1868                 :             : 
    1869                 :        1649 : constexpr void ArgsCache::set_skip_all(uint8_t index, const char* name) {
    1870                 :        1649 :     set_argument<Arg::SkipAll>(index, name, GI_TRANSFER_NOTHING,
    1871                 :             :                                GjsArgumentFlags::SKIP_ALL);
    1872                 :        1649 : }
    1873                 :             : 
    1874                 :             : template <Arg::Kind ArgKind>
    1875                 :        1049 : void ArgsCache::set_array_argument(GICallableInfo* callable, uint8_t gi_index,
    1876                 :             :                                    GITypeInfo* type_info, GIDirection direction,
    1877                 :             :                                    GIArgInfo* arg, GjsArgumentFlags flags,
    1878                 :             :                                    int length_pos) {
    1879                 :             :     Arg::ExplicitArray* array;
    1880                 :             :     GIArgInfo length_arg;
    1881                 :        1049 :     g_callable_info_load_arg(callable, length_pos, &length_arg);
    1882                 :             :     GITypeInfo length_type;
    1883                 :        1049 :     g_arg_info_load_type(&length_arg, &length_type);
    1884                 :             : 
    1885                 :             :     if constexpr (ArgKind == Arg::Kind::RETURN_VALUE) {
    1886                 :         140 :         GITransfer transfer = g_callable_info_get_caller_owns(callable);
    1887                 :         140 :         array = set_return<Arg::ReturnArray>(type_info, transfer,
    1888                 :             :                                              GjsArgumentFlags::NONE);
    1889                 :             :     } else {
    1890                 :         909 :         const char* arg_name = g_base_info_get_name(arg);
    1891                 :         909 :         GITransfer transfer = g_arg_info_get_ownership_transfer(arg);
    1892                 :         909 :         auto common_args =
    1893                 :             :             std::make_tuple(gi_index, arg_name, type_info, transfer, flags);
    1894                 :             : 
    1895         [ +  + ]:         909 :         if (direction == GI_DIRECTION_IN) {
    1896                 :         876 :             array = set_argument_auto<Arg::CArrayIn>(common_args);
    1897                 :         876 :             set_skip_all(length_pos, g_base_info_get_name(&length_arg));
    1898         [ +  + ]:          33 :         } else if (direction == GI_DIRECTION_INOUT) {
    1899                 :          13 :             array = set_argument_auto<Arg::CArrayInOut>(common_args);
    1900                 :          13 :             set_skip_all(length_pos, g_base_info_get_name(&length_arg));
    1901                 :             :         } else {
    1902                 :          20 :             array = set_argument_auto<Arg::CArrayOut>(common_args);
    1903                 :             :         }
    1904                 :             :     }
    1905                 :             : 
    1906         [ +  + ]:         909 :     if (ArgKind == Arg::Kind::RETURN_VALUE || direction == GI_DIRECTION_OUT) {
    1907                 :             :         // Even if we skip the length argument most of time, we need to
    1908                 :             :         // do some basic initialization here.
    1909                 :         160 :         set_argument<Arg::ArrayLengthOut>(
    1910                 :             :             length_pos, g_base_info_get_name(&length_arg), &length_type,
    1911                 :             :             GI_TRANSFER_NOTHING,
    1912                 :         180 :             static_cast<GjsArgumentFlags>(flags | GjsArgumentFlags::SKIP_ALL));
    1913                 :             :     }
    1914                 :             : 
    1915                 :        1049 :     array->set_array_length(length_pos, g_type_info_get_tag(&length_type),
    1916                 :             :                             g_arg_info_get_direction(&length_arg));
    1917                 :        1049 : }
    1918                 :             : 
    1919                 :       10918 : void ArgsCache::build_return(GICallableInfo* callable, bool* inc_counter_out) {
    1920                 :       10918 :     g_assert(inc_counter_out && "forgot out parameter");
    1921                 :             : 
    1922         [ +  + ]:       10918 :     if (!m_has_return) {
    1923                 :        2297 :         *inc_counter_out = false;
    1924                 :        6112 :         return;
    1925                 :             :     }
    1926                 :             : 
    1927                 :             :     GITypeInfo type_info;
    1928                 :        8621 :     g_callable_info_load_return_type(callable, &type_info);
    1929                 :        8621 :     GITransfer transfer = g_callable_info_get_caller_owns(callable);
    1930                 :        8621 :     GITypeTag tag = g_type_info_get_tag(&type_info);
    1931                 :             : 
    1932                 :        8621 :     *inc_counter_out = true;
    1933                 :        8621 :     GjsArgumentFlags flags = GjsArgumentFlags::SKIP_IN;
    1934                 :             : 
    1935         [ +  + ]:        8621 :     if (g_callable_info_may_return_null(callable))
    1936                 :         540 :         flags |= GjsArgumentFlags::MAY_BE_NULL;
    1937                 :             : 
    1938   [ +  +  +  +  :        8621 :     switch (tag) {
          +  +  +  +  +  
             +  +  +  +  
                      + ]
    1939                 :        1324 :         case GI_TYPE_TAG_BOOLEAN:
    1940                 :        1324 :             set_return<Arg::BooleanReturn>(&type_info, transfer, flags);
    1941                 :        1324 :             return;
    1942                 :             : 
    1943                 :           5 :         case GI_TYPE_TAG_INT8:
    1944                 :           5 :             set_return<Arg::NumericReturn<int8_t, GI_TYPE_TAG_INT8>>(
    1945                 :             :                 &type_info, transfer, flags);
    1946                 :           5 :             return;
    1947                 :             : 
    1948                 :           6 :         case GI_TYPE_TAG_INT16:
    1949                 :           6 :             set_return<Arg::NumericReturn<int16_t, GI_TYPE_TAG_INT16>>(
    1950                 :             :                 &type_info, transfer, flags);
    1951                 :           6 :             return;
    1952                 :             : 
    1953                 :          91 :         case GI_TYPE_TAG_INT32:
    1954                 :          91 :             set_return<Arg::NumericReturn<int32_t, GI_TYPE_TAG_INT32>>(
    1955                 :             :                 &type_info, transfer, flags);
    1956                 :          91 :             return;
    1957                 :             : 
    1958                 :           8 :         case GI_TYPE_TAG_UINT8:
    1959                 :           8 :             set_return<Arg::NumericReturn<uint8_t, GI_TYPE_TAG_UINT8>>(
    1960                 :             :                 &type_info, transfer, flags);
    1961                 :           8 :             return;
    1962                 :             : 
    1963                 :           5 :         case GI_TYPE_TAG_UINT16:
    1964                 :           5 :             set_return<Arg::NumericReturn<uint16_t, GI_TYPE_TAG_UINT16>>(
    1965                 :             :                 &type_info, transfer, flags);
    1966                 :           5 :             return;
    1967                 :             : 
    1968                 :         710 :         case GI_TYPE_TAG_UINT32:
    1969                 :         710 :             set_return<Arg::NumericReturn<uint32_t, GI_TYPE_TAG_UINT32>>(
    1970                 :             :                 &type_info, transfer, flags);
    1971                 :         710 :             return;
    1972                 :             : 
    1973                 :          51 :         case GI_TYPE_TAG_INT64:
    1974                 :          51 :             set_return<Arg::NumericReturn<int64_t, GI_TYPE_TAG_INT64>>(
    1975                 :             :                 &type_info, transfer, flags);
    1976                 :          51 :             return;
    1977                 :             : 
    1978                 :         165 :         case GI_TYPE_TAG_UINT64:
    1979                 :         165 :             set_return<Arg::NumericReturn<uint64_t, GI_TYPE_TAG_UINT64>>(
    1980                 :             :                 &type_info, transfer, flags);
    1981                 :         165 :             return;
    1982                 :             : 
    1983                 :           3 :         case GI_TYPE_TAG_FLOAT:
    1984                 :           3 :             set_return<Arg::NumericReturn<float, GI_TYPE_TAG_FLOAT>>(
    1985                 :             :                 &type_info, transfer, flags);
    1986                 :           3 :             return;
    1987                 :             : 
    1988                 :          29 :         case GI_TYPE_TAG_DOUBLE:
    1989                 :          29 :             set_return<Arg::NumericReturn<double, GI_TYPE_TAG_DOUBLE>>(
    1990                 :             :                 &type_info, transfer, flags);
    1991                 :          29 :             return;
    1992                 :             : 
    1993                 :        1278 :         case GI_TYPE_TAG_UTF8:
    1994         [ +  + ]:        1278 :             if (transfer == GI_TRANSFER_NOTHING) {
    1995                 :         218 :                 set_return<Arg::StringReturn<GI_TRANSFER_NOTHING>>(
    1996                 :             :                     &type_info, transfer, flags);
    1997                 :         218 :                 return;
    1998                 :             :             } else {
    1999                 :        1060 :                 set_return<Arg::StringReturn<GI_TRANSFER_EVERYTHING>>(
    2000                 :             :                     &type_info, transfer, flags);
    2001                 :        1060 :                 return;
    2002                 :             :             }
    2003                 :             : 
    2004                 :         347 :         case GI_TYPE_TAG_ARRAY: {
    2005                 :         347 :             int length_pos = g_type_info_get_array_length(&type_info);
    2006         [ +  + ]:         347 :             if (length_pos >= 0) {
    2007                 :         140 :                 set_array_argument<Arg::Kind::RETURN_VALUE>(
    2008                 :             :                     callable, 0, &type_info, GI_DIRECTION_OUT, nullptr, flags,
    2009                 :             :                     length_pos);
    2010                 :         140 :                 return;
    2011                 :             :             }
    2012                 :             : 
    2013                 :             :             [[fallthrough]];
    2014                 :             :         }
    2015                 :             : 
    2016                 :             :         default:
    2017                 :        4806 :             break;
    2018                 :             :     }
    2019                 :             : 
    2020                 :             :     // in() is ignored for the return value, but skip_in is not (it is used
    2021                 :             :     // in the failure release path)
    2022                 :        4806 :     set_return<Arg::GenericReturn>(&type_info, transfer, flags);
    2023                 :             : }
    2024                 :             : 
    2025                 :             : namespace Arg {
    2026                 :             : 
    2027                 :         230 : Enum::Enum(GIEnumInfo* enum_info) {
    2028                 :         230 :     int64_t min = std::numeric_limits<int64_t>::max();
    2029                 :         230 :     int64_t max = std::numeric_limits<int64_t>::min();
    2030                 :         230 :     int n = g_enum_info_get_n_values(enum_info);
    2031         [ +  + ]:        2941 :     for (int i = 0; i < n; i++) {
    2032                 :        2711 :         GjsAutoValueInfo value_info = g_enum_info_get_value(enum_info, i);
    2033                 :        2711 :         int64_t value = g_value_info_get_value(value_info);
    2034                 :             : 
    2035         [ +  + ]:        2711 :         if (value > max)
    2036                 :        2685 :             max = value;
    2037         [ +  + ]:        2711 :         if (value < min)
    2038                 :         240 :             min = value;
    2039                 :        2711 :     }
    2040                 :             : 
    2041                 :             :     // From the docs for g_value_info_get_value(): "This will always be
    2042                 :             :     // representable as a 32-bit signed or unsigned value. The use of gint64 as
    2043                 :             :     // the return type is to allow both."
    2044                 :             :     // We stuff them both into unsigned 32-bit fields, and use a flag to tell
    2045                 :             :     // whether we have to compare them as signed.
    2046                 :         230 :     m_min = static_cast<uint32_t>(min);
    2047                 :         230 :     m_max = static_cast<uint32_t>(max);
    2048                 :             : 
    2049   [ +  +  +  + ]:         230 :     m_unsigned = (min >= 0 && max > std::numeric_limits<int32_t>::max());
    2050                 :         230 : }
    2051                 :             : 
    2052                 :        1470 : Flags::Flags(GIEnumInfo* enum_info) {
    2053                 :        1470 :     uint64_t mask = 0;
    2054                 :        1470 :     int n = g_enum_info_get_n_values(enum_info);
    2055         [ +  + ]:       17046 :     for (int i = 0; i < n; i++) {
    2056                 :       15576 :         GjsAutoValueInfo value_info = g_enum_info_get_value(enum_info, i);
    2057                 :       15576 :         int64_t value = g_value_info_get_value(value_info);
    2058                 :             :         // From the docs for g_value_info_get_value(): "This will always be
    2059                 :             :         // representable as a 32-bit signed or unsigned value. The use of
    2060                 :             :         // gint64 as the return type is to allow both."
    2061                 :             :         // We stuff both into an unsigned, int-sized field, matching the
    2062                 :             :         // internal representation of flags in GLib (which uses guint).
    2063                 :       15576 :         mask |= static_cast<unsigned>(value);
    2064                 :       15576 :     }
    2065                 :             : 
    2066                 :        1470 :     m_mask = mask;
    2067                 :        1470 : }
    2068                 :             : 
    2069                 :             : }  // namespace Arg
    2070                 :             : 
    2071                 :             : namespace arg_cache {
    2072                 :        6452 : [[nodiscard]] static inline bool is_gdk_atom(GIBaseInfo* info) {
    2073         [ -  + ]:        6452 :     return strcmp("Atom", g_base_info_get_name(info)) == 0 &&
    2074         [ -  - ]:        6452 :            strcmp("Gdk", g_base_info_get_namespace(info)) == 0;
    2075                 :             : }
    2076                 :             : }  // namespace arg_cache
    2077                 :             : 
    2078                 :             : template <Arg::Kind ArgKind>
    2079                 :        8559 : void ArgsCache::build_interface_in_arg(uint8_t gi_index, GITypeInfo* type_info,
    2080                 :             :                                        GIBaseInfo* interface_info,
    2081                 :             :                                        GITransfer transfer, const char* name,
    2082                 :             :                                        GjsArgumentFlags flags) {
    2083                 :        8559 :     GIInfoType interface_type = g_base_info_get_type(interface_info);
    2084                 :             : 
    2085                 :        8559 :     auto base_args =
    2086                 :             :         std::make_tuple(gi_index, name, type_info, transfer, flags);
    2087                 :        8559 :     auto common_args =
    2088                 :        2864 :         std::tuple_cat(base_args, std::make_tuple(interface_info));
    2089                 :             : 
    2090                 :             :     // We do some transfer magic later, so let's ensure we don't mess up.
    2091                 :             :     // Should not happen in practice.
    2092         [ -  + ]:        8559 :     if (G_UNLIKELY(transfer == GI_TRANSFER_CONTAINER)) {
    2093                 :           0 :         set_argument_auto<Arg::NotIntrospectable>(base_args,
    2094                 :           0 :                                                   INTERFACE_TRANSFER_CONTAINER);
    2095                 :        8559 :         return;
    2096                 :             :     }
    2097                 :             : 
    2098   [ +  +  +  +  :        8559 :     switch (interface_type) {
                      - ]
    2099                 :         230 :         case GI_INFO_TYPE_ENUM:
    2100                 :         230 :             set_argument_auto<Arg::EnumIn, ArgKind>(common_args);
    2101                 :         230 :             return;
    2102                 :             : 
    2103                 :        1470 :         case GI_INFO_TYPE_FLAGS:
    2104                 :        1470 :             set_argument_auto<Arg::FlagsIn, ArgKind>(common_args);
    2105                 :        1470 :             return;
    2106                 :             : 
    2107                 :        3061 :         case GI_INFO_TYPE_STRUCT:
    2108         [ +  + ]:        3061 :             if (g_struct_info_is_foreign(interface_info)) {
    2109                 :             :                 if constexpr (ArgKind == Arg::Kind::INSTANCE)
    2110                 :           0 :                     set_argument_auto<Arg::ForeignStructInstanceIn, ArgKind>(
    2111                 :             :                         common_args);
    2112                 :             :                 else
    2113                 :          15 :                     set_argument_auto<Arg::ForeignStructIn, ArgKind>(
    2114                 :             :                         common_args);
    2115                 :          15 :                 return;
    2116                 :             :             }
    2117                 :             :             [[fallthrough]];
    2118                 :             :         case GI_INFO_TYPE_BOXED:
    2119                 :             :         case GI_INFO_TYPE_OBJECT:
    2120                 :             :         case GI_INFO_TYPE_INTERFACE:
    2121                 :             :         case GI_INFO_TYPE_UNION: {
    2122                 :        6844 :             GType gtype = g_registered_type_info_get_g_type(interface_info);
    2123                 :             : 
    2124   [ +  +  +  +  :        7164 :             if (interface_type == GI_INFO_TYPE_STRUCT && gtype == G_TYPE_NONE &&
             +  -  +  + ]
    2125                 :         320 :                 !g_struct_info_is_gtype_struct(interface_info)) {
    2126                 :             :                 if constexpr (ArgKind != Arg::Kind::INSTANCE) {
    2127                 :             :                     // This covers cases such as GTypeInstance
    2128                 :         313 :                     set_argument_auto<Arg::FallbackInterfaceIn, ArgKind>(
    2129                 :             :                         common_args);
    2130                 :         313 :                     return;
    2131                 :             :                 }
    2132                 :             :             }
    2133                 :             : 
    2134                 :             :             // Transfer handling is a bit complex here, because some of our in()
    2135                 :             :             // arguments know not to copy stuff if we don't need to.
    2136                 :             : 
    2137         [ +  + ]:        6531 :             if (gtype == G_TYPE_VALUE) {
    2138                 :             :                 if constexpr (ArgKind == Arg::Kind::INSTANCE)
    2139                 :          55 :                     set_argument_auto<Arg::BoxedIn, ArgKind>(common_args);
    2140         [ +  - ]:          24 :                 else if (transfer == GI_TRANSFER_NOTHING)
    2141                 :          24 :                     set_argument_auto<Arg::GValueInTransferNone, ArgKind>(
    2142                 :             :                         common_args);
    2143                 :             :                 else
    2144                 :           0 :                     set_argument_auto<Arg::GValueIn, ArgKind>(common_args);
    2145                 :          79 :                 return;
    2146                 :             :             }
    2147                 :             : 
    2148         [ -  + ]:        6452 :             if (arg_cache::is_gdk_atom(interface_info)) {
    2149                 :             :                 // Fall back to the generic marshaller
    2150                 :           0 :                 set_argument_auto<Arg::FallbackInterfaceIn, ArgKind>(
    2151                 :             :                     common_args);
    2152                 :           0 :                 return;
    2153                 :             :             }
    2154                 :             : 
    2155         [ +  + ]:        6452 :             if (gtype == G_TYPE_CLOSURE) {
    2156         [ +  - ]:         707 :                 if (transfer == GI_TRANSFER_NOTHING &&
    2157                 :             :                     ArgKind != Arg::Kind::INSTANCE)
    2158                 :         707 :                     set_argument_auto<Arg::GClosureInTransferNone, ArgKind>(
    2159                 :             :                         common_args);
    2160                 :             :                 else
    2161                 :           0 :                     set_argument_auto<Arg::GClosureIn, ArgKind>(common_args);
    2162                 :         707 :                 return;
    2163                 :             :             }
    2164                 :             : 
    2165         [ +  + ]:        5745 :             if (gtype == G_TYPE_BYTES) {
    2166         [ +  - ]:          77 :                 if (transfer == GI_TRANSFER_NOTHING &&
    2167                 :             :                     ArgKind != Arg::Kind::INSTANCE)
    2168                 :          77 :                     set_argument_auto<Arg::GBytesInTransferNone, ArgKind>(
    2169                 :             :                         common_args);
    2170                 :             :                 else
    2171                 :           2 :                     set_argument_auto<Arg::GBytesIn, ArgKind>(common_args);
    2172                 :          79 :                 return;
    2173                 :             :             }
    2174                 :             : 
    2175   [ +  +  +  +  :        5666 :             if (g_type_is_a(gtype, G_TYPE_OBJECT)) {
                   +  + ]
    2176                 :        3640 :                 set_argument_auto<Arg::ObjectIn, ArgKind>(common_args);
    2177                 :        3640 :                 return;
    2178                 :             :             }
    2179                 :             : 
    2180   [ +  +  -  +  :        2026 :             if (g_type_is_a(gtype, G_TYPE_PARAM)) {
                   +  + ]
    2181                 :         145 :                 set_argument_auto<Arg::FallbackInterfaceIn, ArgKind>(
    2182                 :             :                     common_args);
    2183                 :         145 :                 return;
    2184                 :             :             }
    2185                 :             : 
    2186         [ +  + ]:        1881 :             if (interface_type == GI_INFO_TYPE_UNION) {
    2187         [ -  + ]:           8 :                 if (gtype == G_TYPE_NONE) {
    2188                 :             :                     // Can't handle unions without a GType
    2189                 :           0 :                     set_argument_auto<Arg::NotIntrospectable>(
    2190                 :           0 :                         base_args, UNREGISTERED_UNION);
    2191                 :           0 :                     return;
    2192                 :             :                 }
    2193                 :             : 
    2194                 :           8 :                 set_argument_auto<Arg::UnionIn, ArgKind>(common_args);
    2195                 :           8 :                 return;
    2196                 :             :             }
    2197                 :             : 
    2198         [ +  + ]:        1873 :             if (G_TYPE_IS_INSTANTIATABLE(gtype)) {
    2199                 :           1 :                 set_argument_auto<Arg::FundamentalIn, ArgKind>(common_args);
    2200                 :           1 :                 return;
    2201                 :             :             }
    2202                 :             : 
    2203   [ +  -  +  +  :        1872 :             if (g_type_is_a(gtype, G_TYPE_INTERFACE)) {
                   +  + ]
    2204                 :           4 :                 set_argument_auto<Arg::InterfaceIn, ArgKind>(common_args);
    2205                 :           4 :                 return;
    2206                 :             :             }
    2207                 :             : 
    2208                 :             :             // generic boxed type
    2209         [ +  + ]:        1868 :             if (gtype == G_TYPE_NONE) {
    2210         [ -  + ]:           7 :                 if (transfer != GI_TRANSFER_NOTHING) {
    2211                 :             :                     // Can't transfer ownership of a structure type not
    2212                 :             :                     // registered as a boxed
    2213                 :           0 :                     set_argument_auto<Arg::NotIntrospectable>(
    2214                 :           0 :                         base_args, UNREGISTERED_BOXED_WITH_TRANSFER);
    2215                 :           0 :                     return;
    2216                 :             :                 }
    2217                 :             : 
    2218                 :           7 :                 set_argument_auto<Arg::UnregisteredBoxedIn, ArgKind>(
    2219                 :             :                     common_args);
    2220                 :           7 :                 return;
    2221                 :             :             }
    2222                 :        1861 :             set_argument_auto<Arg::BoxedIn, ArgKind>(common_args);
    2223                 :        1861 :             return;
    2224                 :             :         } break;
    2225                 :             : 
    2226                 :           0 :         case GI_INFO_TYPE_INVALID:
    2227                 :             :         case GI_INFO_TYPE_FUNCTION:
    2228                 :             :         case GI_INFO_TYPE_CALLBACK:
    2229                 :             :         case GI_INFO_TYPE_CONSTANT:
    2230                 :             :         case GI_INFO_TYPE_INVALID_0:
    2231                 :             :         case GI_INFO_TYPE_VALUE:
    2232                 :             :         case GI_INFO_TYPE_SIGNAL:
    2233                 :             :         case GI_INFO_TYPE_VFUNC:
    2234                 :             :         case GI_INFO_TYPE_PROPERTY:
    2235                 :             :         case GI_INFO_TYPE_FIELD:
    2236                 :             :         case GI_INFO_TYPE_ARG:
    2237                 :             :         case GI_INFO_TYPE_TYPE:
    2238                 :             :         case GI_INFO_TYPE_UNRESOLVED:
    2239                 :             :         default:
    2240                 :             :             // Don't know how to handle this interface type (should not happen
    2241                 :             :             // in practice, for typelibs emitted by g-ir-compiler)
    2242                 :           0 :             set_argument_auto<Arg::NotIntrospectable>(base_args,
    2243                 :           0 :                                                       UNSUPPORTED_TYPE);
    2244                 :             :     }
    2245                 :             : }
    2246                 :             : 
    2247                 :       16609 : void ArgsCache::build_normal_in_arg(uint8_t gi_index, GITypeInfo* type_info,
    2248                 :             :                                     GIArgInfo* arg, GjsArgumentFlags flags) {
    2249                 :             :     // "Normal" in arguments are those arguments that don't require special
    2250                 :             :     // processing, and don't touch other arguments.
    2251                 :             :     // Main categories are:
    2252                 :             :     // - void*
    2253                 :             :     // - small numbers (fit in 32bit)
    2254                 :             :     // - big numbers (need a double)
    2255                 :             :     // - strings
    2256                 :             :     // - enums/flags (different from numbers in the way they're exposed in GI)
    2257                 :             :     // - objects (GObjects, boxed, unions, etc.)
    2258                 :             :     // - hashes
    2259                 :             :     // - sequences (null-terminated arrays, lists, etc.)
    2260                 :             : 
    2261                 :       16609 :     const char* name = g_base_info_get_name(arg);
    2262                 :       16609 :     GITransfer transfer = g_arg_info_get_ownership_transfer(arg);
    2263                 :             :     auto common_args =
    2264                 :       16609 :         std::make_tuple(gi_index, name, type_info, transfer, flags);
    2265                 :       16609 :     GITypeTag tag = g_type_info_get_tag(type_info);
    2266                 :             : 
    2267   [ +  +  +  +  :       16609 :     switch (tag) {
          +  +  +  +  +  
          +  +  +  +  +  
             +  +  +  + ]
    2268                 :         928 :         case GI_TYPE_TAG_VOID:
    2269                 :         928 :             set_argument_auto<Arg::NullIn>(common_args);
    2270                 :         928 :             break;
    2271                 :             : 
    2272                 :         378 :         case GI_TYPE_TAG_BOOLEAN:
    2273                 :         378 :             set_argument_auto<Arg::BooleanIn>(common_args);
    2274                 :         378 :             break;
    2275                 :             : 
    2276                 :         137 :         case GI_TYPE_TAG_INT8:
    2277                 :         137 :             set_argument_auto<Arg::NumericIn<int8_t>>(common_args);
    2278                 :        9187 :             return;
    2279                 :             : 
    2280                 :          68 :         case GI_TYPE_TAG_INT16:
    2281                 :          68 :             set_argument_auto<Arg::NumericIn<int16_t>>(common_args);
    2282                 :          68 :             return;
    2283                 :             : 
    2284                 :         977 :         case GI_TYPE_TAG_INT32:
    2285                 :         977 :             set_argument_auto<Arg::NumericIn<int32_t>>(common_args);
    2286                 :         977 :             return;
    2287                 :             : 
    2288                 :          68 :         case GI_TYPE_TAG_UINT8:
    2289                 :          68 :             set_argument_auto<Arg::NumericIn<uint8_t>>(common_args);
    2290                 :          68 :             return;
    2291                 :             : 
    2292                 :          73 :         case GI_TYPE_TAG_UINT16:
    2293                 :          73 :             set_argument_auto<Arg::NumericIn<uint16_t>>(common_args);
    2294                 :          73 :             return;
    2295                 :             : 
    2296                 :        1393 :         case GI_TYPE_TAG_UINT32:
    2297                 :        1393 :             set_argument_auto<Arg::NumericIn<uint32_t>>(common_args);
    2298                 :        1393 :             return;
    2299                 :             : 
    2300                 :         249 :         case GI_TYPE_TAG_INT64:
    2301                 :         249 :             set_argument_auto<Arg::NumericIn<int64_t>>(common_args);
    2302                 :         249 :             return;
    2303                 :             : 
    2304                 :         304 :         case GI_TYPE_TAG_UINT64:
    2305                 :         304 :             set_argument_auto<Arg::NumericIn<uint64_t>>(common_args);
    2306                 :         304 :             return;
    2307                 :             : 
    2308                 :           3 :         case GI_TYPE_TAG_FLOAT:
    2309                 :           3 :             set_argument_auto<Arg::NumericIn<float>>(common_args);
    2310                 :           3 :             return;
    2311                 :             : 
    2312                 :         220 :         case GI_TYPE_TAG_DOUBLE:
    2313                 :         220 :             set_argument_auto<Arg::NumericIn<double>>(common_args);
    2314                 :         220 :             return;
    2315                 :             : 
    2316                 :           1 :         case GI_TYPE_TAG_UNICHAR:
    2317                 :           1 :             set_argument_auto<Arg::UnicharIn>(common_args);
    2318                 :           1 :             break;
    2319                 :             : 
    2320                 :         194 :         case GI_TYPE_TAG_GTYPE:
    2321                 :         194 :             set_argument_auto<Arg::GTypeIn>(common_args);
    2322                 :         194 :             break;
    2323                 :             : 
    2324                 :         216 :         case GI_TYPE_TAG_FILENAME:
    2325         [ +  - ]:         216 :             if (transfer == GI_TRANSFER_NOTHING)
    2326                 :         216 :                 set_argument_auto<Arg::FilenameInTransferNone>(common_args);
    2327                 :             :             else
    2328                 :           0 :                 set_argument_auto<Arg::FilenameIn>(common_args);
    2329                 :         216 :             break;
    2330                 :             : 
    2331                 :        5598 :         case GI_TYPE_TAG_UTF8:
    2332         [ +  - ]:        5598 :             if (transfer == GI_TRANSFER_NOTHING)
    2333                 :        5598 :                 set_argument_auto<Arg::StringInTransferNone<GI_TYPE_TAG_UTF8>>(
    2334                 :             :                     common_args);
    2335                 :             :             else
    2336                 :           0 :                 set_argument_auto<Arg::StringIn>(common_args);
    2337                 :        5598 :             break;
    2338                 :             : 
    2339                 :        5695 :         case GI_TYPE_TAG_INTERFACE: {
    2340                 :             :             GjsAutoBaseInfo interface_info =
    2341                 :        5695 :                 g_type_info_get_interface(type_info);
    2342                 :        5695 :             build_interface_in_arg(gi_index, type_info, interface_info,
    2343                 :             :                                    transfer, name, flags);
    2344                 :        5695 :             return;
    2345                 :        5695 :         }
    2346                 :             : 
    2347                 :         107 :         case GI_TYPE_TAG_ARRAY:
    2348                 :             :         case GI_TYPE_TAG_GLIST:
    2349                 :             :         case GI_TYPE_TAG_GSLIST:
    2350                 :             :         case GI_TYPE_TAG_GHASH:
    2351                 :             :         case GI_TYPE_TAG_ERROR:
    2352                 :             :         default:
    2353                 :             :             // FIXME: Falling back to the generic marshaller
    2354                 :         107 :             set_argument_auto<Arg::FallbackIn>(common_args);
    2355                 :             :     }
    2356                 :             : }
    2357                 :             : 
    2358                 :         618 : void ArgsCache::build_normal_out_arg(uint8_t gi_index, GITypeInfo* type_info,
    2359                 :             :                                      GIArgInfo* arg, GjsArgumentFlags flags) {
    2360                 :         618 :     const char* name = g_base_info_get_name(arg);
    2361                 :         618 :     GITransfer transfer = g_arg_info_get_ownership_transfer(arg);
    2362                 :             :     auto common_args =
    2363                 :         618 :         std::make_tuple(gi_index, name, type_info, transfer, flags);
    2364                 :         618 :     GITypeTag tag = g_type_info_get_tag(type_info);
    2365                 :             : 
    2366   [ +  +  +  +  :         618 :     switch (tag) {
          +  +  +  +  +  
             +  +  +  + ]
    2367                 :          70 :         case GI_TYPE_TAG_BOOLEAN:
    2368                 :          70 :             set_argument_auto<Arg::BooleanOut>(common_args);
    2369                 :          70 :             break;
    2370                 :             : 
    2371                 :           5 :         case GI_TYPE_TAG_INT8:
    2372                 :           5 :             set_argument_auto<Arg::NumericOut<int8_t>>(common_args);
    2373                 :         188 :             return;
    2374                 :             : 
    2375                 :           4 :         case GI_TYPE_TAG_INT16:
    2376                 :           4 :             set_argument_auto<Arg::NumericOut<int16_t>>(common_args);
    2377                 :           4 :             return;
    2378                 :             : 
    2379                 :          47 :         case GI_TYPE_TAG_INT32:
    2380                 :          47 :             set_argument_auto<Arg::NumericOut<int32_t>>(common_args);
    2381                 :          47 :             return;
    2382                 :             : 
    2383                 :           1 :         case GI_TYPE_TAG_UINT8:
    2384                 :           1 :             set_argument_auto<Arg::NumericOut<uint8_t>>(common_args);
    2385                 :           1 :             return;
    2386                 :             : 
    2387                 :           2 :         case GI_TYPE_TAG_UINT16:
    2388                 :           2 :             set_argument_auto<Arg::NumericOut<uint16_t>>(common_args);
    2389                 :           2 :             return;
    2390                 :             : 
    2391                 :          12 :         case GI_TYPE_TAG_UINT32:
    2392                 :          12 :             set_argument_auto<Arg::NumericOut<uint32_t>>(common_args);
    2393                 :          12 :             return;
    2394                 :             : 
    2395                 :          13 :         case GI_TYPE_TAG_INT64:
    2396                 :          13 :             set_argument_auto<Arg::NumericOut<int64_t>>(common_args);
    2397                 :          13 :             return;
    2398                 :             : 
    2399                 :          15 :         case GI_TYPE_TAG_UINT64:
    2400                 :          15 :             set_argument_auto<Arg::NumericOut<uint64_t>>(common_args);
    2401                 :          15 :             return;
    2402                 :             : 
    2403                 :           7 :         case GI_TYPE_TAG_FLOAT:
    2404                 :           7 :             set_argument_auto<Arg::NumericOut<float>>(common_args);
    2405                 :           7 :             return;
    2406                 :             : 
    2407                 :          12 :         case GI_TYPE_TAG_DOUBLE:
    2408                 :          12 :             set_argument_auto<Arg::NumericOut<double>>(common_args);
    2409                 :          12 :             return;
    2410                 :             : 
    2411                 :          70 :         case GI_TYPE_TAG_UTF8:
    2412         [ +  + ]:          70 :             if (transfer == GI_TRANSFER_NOTHING) {
    2413                 :           4 :                 set_argument_auto<Arg::StringOut<GI_TRANSFER_NOTHING>>(
    2414                 :             :                     common_args);
    2415                 :             :             } else {
    2416                 :          66 :                 set_argument_auto<Arg::StringOut<GI_TRANSFER_EVERYTHING>>(
    2417                 :             :                     common_args);
    2418                 :             :             }
    2419                 :          70 :             return;
    2420                 :             : 
    2421                 :         360 :         default:
    2422                 :         360 :             set_argument_auto<Arg::FallbackOut>(common_args);
    2423                 :             :     }
    2424                 :             : }
    2425                 :             : 
    2426                 :          55 : void ArgsCache::build_normal_inout_arg(uint8_t gi_index, GITypeInfo* type_info,
    2427                 :             :                                        GIArgInfo* arg, GjsArgumentFlags flags) {
    2428                 :          55 :     const char* name = g_base_info_get_name(arg);
    2429                 :          55 :     GITransfer transfer = g_arg_info_get_ownership_transfer(arg);
    2430                 :             :     auto common_args =
    2431                 :          55 :         std::make_tuple(gi_index, name, type_info, transfer, flags);
    2432                 :          55 :     GITypeTag tag = g_type_info_get_tag(type_info);
    2433                 :             : 
    2434   [ +  +  +  +  :          55 :     switch (tag) {
          +  +  +  +  -  
                +  +  + ]
    2435                 :           2 :         case GI_TYPE_TAG_BOOLEAN:
    2436                 :           2 :             set_argument_auto<Arg::BooleanInOut>(common_args);
    2437                 :           2 :             break;
    2438                 :             : 
    2439                 :           2 :         case GI_TYPE_TAG_INT8:
    2440                 :           2 :             set_argument_auto<Arg::NumericInOut<int8_t>>(common_args);
    2441                 :          35 :             return;
    2442                 :             : 
    2443                 :           4 :         case GI_TYPE_TAG_INT16:
    2444                 :           4 :             set_argument_auto<Arg::NumericInOut<int16_t>>(common_args);
    2445                 :           4 :             return;
    2446                 :             : 
    2447                 :          15 :         case GI_TYPE_TAG_INT32:
    2448                 :          15 :             set_argument_auto<Arg::NumericInOut<int32_t>>(common_args);
    2449                 :          15 :             return;
    2450                 :             : 
    2451                 :           1 :         case GI_TYPE_TAG_UINT8:
    2452                 :           1 :             set_argument_auto<Arg::NumericInOut<uint8_t>>(common_args);
    2453                 :           1 :             return;
    2454                 :             : 
    2455                 :           2 :         case GI_TYPE_TAG_UINT16:
    2456                 :           2 :             set_argument_auto<Arg::NumericInOut<uint16_t>>(common_args);
    2457                 :           2 :             return;
    2458                 :             : 
    2459                 :           2 :         case GI_TYPE_TAG_UINT32:
    2460                 :           2 :             set_argument_auto<Arg::NumericInOut<uint32_t>>(common_args);
    2461                 :           2 :             return;
    2462                 :             : 
    2463                 :           4 :         case GI_TYPE_TAG_INT64:
    2464                 :           4 :             set_argument_auto<Arg::NumericInOut<int64_t>>(common_args);
    2465                 :           4 :             return;
    2466                 :             : 
    2467                 :           0 :         case GI_TYPE_TAG_UINT64:
    2468                 :           0 :             set_argument_auto<Arg::NumericInOut<uint64_t>>(common_args);
    2469                 :           0 :             return;
    2470                 :             : 
    2471                 :           4 :         case GI_TYPE_TAG_FLOAT:
    2472                 :           4 :             set_argument_auto<Arg::NumericInOut<float>>(common_args);
    2473                 :           4 :             return;
    2474                 :             : 
    2475                 :           1 :         case GI_TYPE_TAG_DOUBLE:
    2476                 :           1 :             set_argument_auto<Arg::NumericInOut<double>>(common_args);
    2477                 :           1 :             return;
    2478                 :             : 
    2479                 :          18 :         default:
    2480                 :          18 :             set_argument_auto<Arg::FallbackInOut>(common_args);
    2481                 :             :     }
    2482                 :             : }
    2483                 :             : 
    2484                 :       10918 : void ArgsCache::build_instance(GICallableInfo* callable) {
    2485         [ +  + ]:       10918 :     if (!m_is_method)
    2486                 :        7470 :         return;
    2487                 :             : 
    2488                 :        3448 :     GIBaseInfo* interface_info = g_base_info_get_container(callable);  // !owned
    2489                 :             : 
    2490                 :             :     GITransfer transfer =
    2491                 :        3448 :         g_callable_info_get_instance_ownership_transfer(callable);
    2492                 :             : 
    2493                 :             :     // These cases could be covered by the generic marshaller, except that
    2494                 :             :     // there's no way to get GITypeInfo for a method's instance parameter.
    2495                 :             :     // Instead, special-case the arguments here that would otherwise go through
    2496                 :             :     // the generic marshaller.
    2497                 :             :     // See: https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/334
    2498                 :        3448 :     GIInfoType info_type = g_base_info_get_type(interface_info);
    2499   [ +  +  +  +  :        4738 :     if (info_type == GI_INFO_TYPE_STRUCT &&
                   +  + ]
    2500                 :        1290 :         g_struct_info_is_gtype_struct(interface_info)) {
    2501                 :         456 :         set_instance<Arg::GTypeStructInstanceIn>(transfer);
    2502                 :         456 :         return;
    2503                 :             :     }
    2504         [ +  + ]:        2992 :     if (info_type == GI_INFO_TYPE_OBJECT) {
    2505                 :        1847 :         GType gtype = g_registered_type_info_get_g_type(interface_info);
    2506                 :             : 
    2507   [ +  +  -  +  :        1847 :         if (g_type_is_a(gtype, G_TYPE_PARAM)) {
                   +  + ]
    2508                 :         128 :             set_instance<Arg::ParamInstanceIn>(transfer);
    2509                 :         128 :             return;
    2510                 :             :         }
    2511                 :             :     }
    2512                 :             : 
    2513                 :        2864 :     build_interface_in_arg<Arg::Kind::INSTANCE>(
    2514                 :             :         Argument::ABSENT, nullptr, interface_info, transfer, nullptr,
    2515                 :             :         GjsArgumentFlags::NONE);
    2516                 :             : }
    2517                 :             : 
    2518                 :          11 : static constexpr bool type_tag_is_scalar(GITypeTag tag) {
    2519   [ +  -  +  -  :          11 :     return GI_TYPE_TAG_IS_NUMERIC(tag) || tag == GI_TYPE_TAG_BOOLEAN ||
             +  -  -  + ]
    2520                 :          11 :            tag == GI_TYPE_TAG_GTYPE;
    2521                 :             : }
    2522                 :             : 
    2523                 :       19038 : void ArgsCache::build_arg(uint8_t gi_index, GIDirection direction,
    2524                 :             :                           GIArgInfo* arg, GICallableInfo* callable,
    2525                 :             :                           bool* inc_counter_out) {
    2526                 :       19038 :     g_assert(inc_counter_out && "forgot out parameter");
    2527                 :             :     GITypeInfo type_info;
    2528                 :             : 
    2529                 :       19038 :     const char* arg_name = g_base_info_get_name(arg);
    2530                 :       19038 :     g_arg_info_load_type(arg, &type_info);
    2531                 :       19038 :     GITransfer transfer = g_arg_info_get_ownership_transfer(arg);
    2532                 :             : 
    2533                 :       19038 :     GjsArgumentFlags flags = GjsArgumentFlags::NONE;
    2534         [ +  + ]:       19038 :     if (g_arg_info_may_be_null(arg))
    2535                 :        3973 :         flags |= GjsArgumentFlags::MAY_BE_NULL;
    2536         [ +  + ]:       19038 :     if (g_arg_info_is_caller_allocates(arg))
    2537                 :          14 :         flags |= GjsArgumentFlags::CALLER_ALLOCATES;
    2538                 :             : 
    2539         [ +  + ]:       19038 :     if (direction == GI_DIRECTION_IN)
    2540                 :       18315 :         flags |= GjsArgumentFlags::SKIP_OUT;
    2541         [ +  + ]:         723 :     else if (direction == GI_DIRECTION_OUT)
    2542                 :         652 :         flags |= GjsArgumentFlags::SKIP_IN;
    2543                 :       19038 :     *inc_counter_out = true;
    2544                 :             : 
    2545                 :             :     auto common_args =
    2546                 :       19038 :         std::make_tuple(gi_index, arg_name, &type_info, transfer, flags);
    2547                 :             : 
    2548                 :       19038 :     GITypeTag type_tag = g_type_info_get_tag(&type_info);
    2549   [ +  +  +  + ]:       19690 :     if (direction == GI_DIRECTION_OUT &&
    2550         [ +  + ]:       19690 :         (flags & GjsArgumentFlags::CALLER_ALLOCATES)) {
    2551                 :          14 :         size_t size = 0;
    2552                 :             : 
    2553         [ +  + ]:          14 :         if (type_tag == GI_TYPE_TAG_ARRAY) {
    2554                 :           3 :             GIArrayType array_type = g_type_info_get_array_type(&type_info);
    2555                 :             : 
    2556         [ +  + ]:           3 :             switch (array_type) {
    2557                 :           2 :                 case GI_ARRAY_TYPE_C: {
    2558                 :           2 :                     GjsAutoTypeInfo param_info;
    2559                 :             :                     int n_elements =
    2560                 :           2 :                         g_type_info_get_array_fixed_size(&type_info);
    2561                 :             : 
    2562         [ -  + ]:           2 :                     if (n_elements <= 0)
    2563                 :           0 :                         break;
    2564                 :             : 
    2565                 :           2 :                     param_info = g_type_info_get_param_type(&type_info, 0);
    2566                 :           2 :                     GITypeTag param_tag = g_type_info_get_tag(param_info);
    2567                 :             : 
    2568                 :           2 :                     size = gjs_type_get_element_size(param_tag, param_info);
    2569                 :           2 :                     size *= n_elements;
    2570                 :           2 :                     break;
    2571                 :           2 :                 }
    2572                 :           1 :                 default:
    2573                 :           1 :                     break;
    2574                 :             :             }
    2575   [ +  -  +  +  :          22 :         } else if (!type_tag_is_scalar(type_tag) &&
                   +  + ]
    2576                 :          11 :                    !g_type_info_is_pointer(&type_info)) {
    2577                 :             :             // Scalar out parameters should not be annotated with
    2578                 :             :             // caller-allocates, which is for structured types that need to be
    2579                 :             :             // allocated in order for the function to fill them in.
    2580                 :          10 :             size = gjs_type_get_element_size(type_tag, &type_info);
    2581                 :             :         }
    2582                 :             : 
    2583         [ +  + ]:          14 :         if (!size) {
    2584                 :           2 :             set_argument_auto<Arg::NotIntrospectable>(
    2585                 :           2 :                 common_args, OUT_CALLER_ALLOCATES_NON_STRUCT);
    2586                 :           2 :             return;
    2587                 :             :         }
    2588                 :             : 
    2589         [ +  + ]:          12 :         if (type_tag == GI_TYPE_TAG_INTERFACE) {
    2590                 :             :             GjsAutoBaseInfo interface_info =
    2591                 :          10 :                 g_type_info_get_interface(&type_info);
    2592                 :          10 :             GType gtype = g_registered_type_info_get_g_type(interface_info);
    2593   [ +  -  +  +  :          10 :             if (g_type_is_a(gtype, G_TYPE_BOXED)) {
                   +  + ]
    2594                 :           6 :                 auto* gjs_arg = set_argument_auto<Arg::BoxedCallerAllocatesOut>(
    2595                 :             :                     common_args, gtype);
    2596                 :           6 :                 gjs_arg->m_allocates_size = size;
    2597                 :           6 :                 return;
    2598                 :             :             }
    2599         [ +  + ]:          10 :         }
    2600                 :             : 
    2601                 :           6 :         auto* gjs_arg = set_argument_auto<Arg::CallerAllocatesOut>(common_args);
    2602                 :           6 :         gjs_arg->m_allocates_size = size;
    2603                 :             : 
    2604                 :           6 :         return;
    2605                 :             :     }
    2606                 :             : 
    2607         [ +  + ]:       19024 :     if (type_tag == GI_TYPE_TAG_INTERFACE) {
    2608                 :        6742 :         GjsAutoBaseInfo interface_info = g_type_info_get_interface(&type_info);
    2609         [ +  + ]:        6742 :         if (interface_info.type() == GI_INFO_TYPE_CALLBACK) {
    2610         [ -  + ]:         709 :             if (direction != GI_DIRECTION_IN) {
    2611                 :             :                 // Can't do callbacks for out or inout
    2612                 :           0 :                 set_argument_auto<Arg::NotIntrospectable>(common_args,
    2613                 :           0 :                                                           CALLBACK_OUT);
    2614                 :           0 :                 return;
    2615                 :             :             }
    2616                 :             : 
    2617   [ +  +  +  + ]:         773 :             if (strcmp(interface_info.name(), "DestroyNotify") == 0 &&
    2618         [ +  - ]:          64 :                 strcmp(interface_info.ns(), "GLib") == 0) {
    2619                 :             :                 // We don't know (yet) what to do with GDestroyNotify appearing
    2620                 :             :                 // before a callback. If the callback comes later in the
    2621                 :             :                 // argument list, then the invalid argument will be
    2622                 :             :                 // overwritten with the 'skipped' one. If no callback follows,
    2623                 :             :                 // then this is probably an unsupported function, so the
    2624                 :             :                 // function invocation code will check this and throw.
    2625                 :          64 :                 set_argument_auto<Arg::NotIntrospectable>(
    2626                 :          64 :                     common_args, DESTROY_NOTIFY_NO_CALLBACK);
    2627                 :          64 :                 *inc_counter_out = false;
    2628                 :             :             } else {
    2629                 :         645 :                 auto* gjs_arg = set_argument_auto<Arg::CallbackIn>(
    2630                 :             :                     common_args, interface_info);
    2631                 :             : 
    2632                 :         645 :                 int destroy_pos = g_arg_info_get_destroy(arg);
    2633                 :         645 :                 int closure_pos = g_arg_info_get_closure(arg);
    2634                 :             : 
    2635         [ +  + ]:         645 :                 if (destroy_pos >= 0)
    2636                 :         147 :                     set_skip_all(destroy_pos);
    2637                 :             : 
    2638         [ +  + ]:         645 :                 if (closure_pos >= 0)
    2639                 :         613 :                     set_skip_all(closure_pos);
    2640                 :             : 
    2641   [ +  +  +  + ]:         645 :                 if (destroy_pos >= 0 && closure_pos < 0) {
    2642                 :           1 :                     set_argument_auto<Arg::NotIntrospectable>(
    2643                 :           1 :                         common_args, DESTROY_NOTIFY_NO_USER_DATA);
    2644                 :           1 :                     return;
    2645                 :             :                 }
    2646                 :             : 
    2647                 :         644 :                 gjs_arg->m_scope = g_arg_info_get_scope(arg);
    2648                 :         644 :                 gjs_arg->set_callback_destroy_pos(destroy_pos);
    2649                 :         644 :                 gjs_arg->set_callback_closure_pos(closure_pos);
    2650                 :             :             }
    2651                 :             : 
    2652                 :         708 :             return;
    2653                 :             :         }
    2654         [ +  + ]:        6742 :     }
    2655                 :             : 
    2656   [ +  +  +  +  :       19374 :     if (type_tag == GI_TYPE_TAG_ARRAY &&
                   +  + ]
    2657                 :        1059 :         g_type_info_get_array_type(&type_info) == GI_ARRAY_TYPE_C) {
    2658                 :        1044 :         int length_pos = g_type_info_get_array_length(&type_info);
    2659                 :             : 
    2660         [ +  + ]:        1044 :         if (length_pos >= 0) {
    2661                 :         909 :             Argument* cached_length = argument(length_pos);
    2662   [ +  +  +  + ]:         912 :             bool skip_length = cached_length && !(cached_length->skip_in() &&
    2663         [ +  + ]:           3 :                                                   cached_length->skip_out());
    2664                 :             : 
    2665                 :         909 :             set_array_argument(callable, gi_index, &type_info, direction, arg,
    2666                 :             :                                flags, length_pos);
    2667                 :             : 
    2668   [ +  +  +  + ]:         909 :             if (length_pos < gi_index && skip_length) {
    2669                 :             :                 // we already collected length_pos, remove it
    2670                 :         168 :                 *inc_counter_out = false;
    2671                 :             :             }
    2672                 :             : 
    2673                 :         909 :             return;
    2674         [ +  + ]:         135 :         } else if (g_type_info_is_zero_terminated(&type_info)) {
    2675         [ +  + ]:         123 :             if (direction == GI_DIRECTION_IN) {
    2676                 :         116 :                 set_argument_auto<Arg::ZeroTerminatedArrayIn>(common_args);
    2677                 :         116 :                 return;
    2678         [ +  + ]:           7 :             } else if (direction == GI_DIRECTION_INOUT) {
    2679                 :           2 :                 set_argument_auto<Arg::ZeroTerminatedArrayInOut>(common_args);
    2680                 :           2 :                 return;
    2681                 :             :             }
    2682         [ +  + ]:          12 :         } else if (g_type_info_get_array_fixed_size(&type_info) >= 0) {
    2683         [ +  + ]:          11 :             if (direction == GI_DIRECTION_IN) {
    2684                 :           5 :                 set_argument_auto<Arg::FixedSizeArrayIn>(common_args);
    2685                 :           5 :                 return;
    2686         [ +  + ]:           6 :             } else if (direction == GI_DIRECTION_INOUT) {
    2687                 :           1 :                 set_argument_auto<Arg::FixedSizeArrayInOut>(common_args);
    2688                 :           1 :                 return;
    2689                 :             :             }
    2690                 :             :         }
    2691                 :             :     }
    2692                 :             : 
    2693         [ +  + ]:       17282 :     if (direction == GI_DIRECTION_IN)
    2694                 :       16609 :         build_normal_in_arg(gi_index, &type_info, arg, flags);
    2695         [ +  + ]:         673 :     else if (direction == GI_DIRECTION_INOUT)
    2696                 :          55 :         build_normal_inout_arg(gi_index, &type_info, arg, flags);
    2697                 :             :     else
    2698                 :         618 :         build_normal_out_arg(gi_index, &type_info, arg, flags);
    2699                 :             : 
    2700                 :       17282 :     return;
    2701                 :             : }
    2702                 :             : 
    2703                 :             : }  // namespace Gjs
        

Generated by: LCOV version 2.0-1