LCOV - code coverage report
Current view: top level - gi - arg-cache.cpp (source / functions) Coverage Total Hit
Test: gjs- Code Coverage Lines: 89.0 % 1691 1505
Test Date: 2025-05-21 00:02:11 Functions: 89.0 % 735 654
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 77.8 % 821 639

             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 <functional>  // for mem_fn
      14                 :             : #include <limits>
      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                 :             : #include <mozilla/Maybe.h>
      32                 :             : 
      33                 :             : #include "gi/arg-cache.h"
      34                 :             : #include "gi/arg-inl.h"
      35                 :             : #include "gi/arg-types-inl.h"
      36                 :             : #include "gi/arg.h"
      37                 :             : #include "gi/boxed.h"
      38                 :             : #include "gi/closure.h"
      39                 :             : #include "gi/foreign.h"
      40                 :             : #include "gi/function.h"
      41                 :             : #include "gi/fundamental.h"
      42                 :             : #include "gi/gerror.h"
      43                 :             : #include "gi/gtype.h"
      44                 :             : #include "gi/info.h"
      45                 :             : #include "gi/js-value-inl.h"
      46                 :             : #include "gi/object.h"
      47                 :             : #include "gi/param.h"
      48                 :             : #include "gi/union.h"
      49                 :             : #include "gi/value.h"
      50                 :             : #include "gi/wrapperutils.h"  // for GjsTypecheckNoThrow
      51                 :             : #include "gjs/auto.h"
      52                 :             : #include "gjs/byteArray.h"
      53                 :             : #include "gjs/enum-utils.h"  // for operator&, operator|=, operator|
      54                 :             : #include "gjs/jsapi-util.h"
      55                 :             : #include "gjs/macros.h"
      56                 :             : #include "util/log.h"
      57                 :             : 
      58                 :             : using mozilla::Maybe, mozilla::Nothing, mozilla::Some;
      59                 :             : 
      60                 :             : enum ExpectedType {
      61                 :             :     OBJECT,
      62                 :             :     FUNCTION,
      63                 :             :     STRING,
      64                 :             :     LAST,
      65                 :             : };
      66                 :             : 
      67                 :             : static const char* expected_type_names[] = {"object", "function", "string"};
      68                 :             : static_assert(G_N_ELEMENTS(expected_type_names) == ExpectedType::LAST,
      69                 :             :               "Names must match the values in ExpectedType");
      70                 :             : 
      71                 :         360 : static constexpr void gjs_gi_argument_set_array_length(GITypeTag tag,
      72                 :             :                                                        GIArgument* arg,
      73                 :             :                                                        size_t value) {
      74   [ -  +  -  -  :         360 :     switch (tag) {
             +  +  +  +  
                      - ]
      75                 :           0 :         case GI_TYPE_TAG_INT8:
      76                 :           0 :             gjs_arg_set<int8_t>(arg, value);
      77                 :           0 :             break;
      78                 :           1 :         case GI_TYPE_TAG_UINT8:
      79                 :           1 :             gjs_arg_set<uint8_t>(arg, value);
      80                 :           1 :             break;
      81                 :           0 :         case GI_TYPE_TAG_INT16:
      82                 :           0 :             gjs_arg_set<int16_t>(arg, value);
      83                 :           0 :             break;
      84                 :           0 :         case GI_TYPE_TAG_UINT16:
      85                 :           0 :             gjs_arg_set<uint16_t>(arg, value);
      86                 :           0 :             break;
      87                 :          73 :         case GI_TYPE_TAG_INT32:
      88                 :          73 :             gjs_arg_set<int32_t>(arg, value);
      89                 :          73 :             break;
      90                 :           5 :         case GI_TYPE_TAG_UINT32:
      91                 :           5 :             gjs_arg_set<uint32_t>(arg, value);
      92                 :           5 :             break;
      93                 :          17 :         case GI_TYPE_TAG_INT64:
      94                 :          17 :             gjs_arg_set<int64_t>(arg, value);
      95                 :          17 :             break;
      96                 :         264 :         case GI_TYPE_TAG_UINT64:
      97                 :         264 :             gjs_arg_set<uint64_t>(arg, value);
      98                 :         264 :             break;
      99                 :           0 :         default:
     100                 :             :             g_assert_not_reached();
     101                 :             :     }
     102                 :         360 : }
     103                 :             : 
     104                 :             : GJS_JSAPI_RETURN_CONVENTION
     105                 :           2 : static bool report_typeof_mismatch(JSContext* cx, const char* arg_name,
     106                 :             :                                    JS::HandleValue value,
     107                 :             :                                    ExpectedType expected) {
     108                 :           2 :     gjs_throw(cx, "Expected type %s for argument '%s' but got type %s",
     109                 :           2 :               expected_type_names[expected], arg_name,
     110                 :             :               JS::InformalValueTypeName(value));
     111                 :           2 :     return false;
     112                 :             : }
     113                 :             : 
     114                 :             : GJS_JSAPI_RETURN_CONVENTION
     115                 :           0 : static bool report_gtype_mismatch(JSContext* cx, const char* arg_name,
     116                 :             :                                   JS::Value value, GType expected) {
     117                 :           0 :     gjs_throw(
     118                 :             :         cx, "Expected an object of type %s for argument '%s' but got type %s",
     119                 :             :         g_type_name(expected), arg_name, JS::InformalValueTypeName(value));
     120                 :           0 :     return false;
     121                 :             : }
     122                 :             : 
     123                 :             : GJS_JSAPI_RETURN_CONVENTION
     124                 :           3 : static bool report_invalid_null(JSContext* cx, const char* arg_name) {
     125                 :           3 :     gjs_throw(cx, "Argument %s may not be null", arg_name);
     126                 :           3 :     return false;
     127                 :             : }
     128                 :             : 
     129                 :             : // Overload operator| so that Visual Studio won't complain
     130                 :             : // when converting unsigned char to GjsArgumentFlags
     131                 :       30745 : GjsArgumentFlags operator|(
     132                 :             :     GjsArgumentFlags const& v1, GjsArgumentFlags const& v2) {
     133                 :       30745 :     return static_cast<GjsArgumentFlags>(std::underlying_type<GjsArgumentFlags>::type(v1) |
     134                 :       30745 :                                          std::underlying_type<GjsArgumentFlags>::type(v2));
     135                 :             : }
     136                 :             : 
     137                 :             : namespace Gjs {
     138                 :             : namespace Arg {
     139                 :             : 
     140                 :             : // Arguments Interfaces:
     141                 :             : //
     142                 :             : // Each of these types are meant to be used to extend each Gjs::Argument
     143                 :             : // implementation, taking advantage of the C++ multiple inheritance.
     144                 :             : 
     145                 :             : struct BasicType {
     146                 :        1800 :     constexpr explicit BasicType(GITypeTag tag) : m_tag(tag) {
     147                 :        1800 :         g_assert(GI_TYPE_TAG_IS_BASIC(tag));
     148                 :        1800 :     }
     149                 :             : 
     150                 :             :     GITypeTag m_tag : 5;
     151                 :             : };
     152                 :             : 
     153                 :             : struct HasTypeInfo {
     154                 :        5573 :     constexpr explicit HasTypeInfo(GI::TypeInfo info) {
     155                 :        5573 :         GI::detail::Pointer::to_stack(GI::detail::Pointer::get_from(info),
     156                 :             :                                       &m_type_info);
     157                 :        5573 :     }
     158                 :             : 
     159                 :       21580 :     Maybe<ReturnTag> return_tag() const { return Some(ReturnTag{m_type_info}); }
     160                 :             : 
     161                 :             :     GI::StackTypeInfo m_type_info;
     162                 :             : };
     163                 :             : 
     164                 :             : struct Transferable {
     165                 :       14222 :     constexpr Transferable() : m_transfer(GI_TRANSFER_NOTHING) {}
     166                 :             :     constexpr explicit Transferable(GITransfer transfer)
     167                 :             :         : m_transfer(transfer) {}
     168                 :             :     GITransfer m_transfer : 2;
     169                 :             : };
     170                 :             : 
     171                 :             : struct Nullable {
     172                 :       19499 :     constexpr Nullable() : m_nullable(false) {}
     173                 :             :     bool m_nullable : 1;
     174                 :             : 
     175                 :             :     bool handle_nullable(JSContext* cx, GIArgument* arg, const char* arg_name);
     176                 :             : 
     177                 :         591 :     constexpr GjsArgumentFlags flags() const {
     178         [ +  + ]:         591 :         return m_nullable ? GjsArgumentFlags::MAY_BE_NULL
     179                 :         591 :                           : GjsArgumentFlags::NONE;
     180                 :             :     }
     181                 :             : };
     182                 :             : 
     183                 :             : struct Positioned {
     184                 :        1773 :     void set_arg_pos(int pos) {
     185                 :        1773 :         g_assert(pos <= Argument::MAX_ARGS &&
     186                 :             :                  "No more than 253 arguments allowed");
     187                 :        1773 :         m_arg_pos = pos;
     188                 :        1773 :     }
     189                 :             : 
     190                 :         810 :     constexpr bool set_out_parameter(GjsFunctionCallState* state,
     191                 :             :                                      GIArgument* arg) {
     192                 :         810 :         gjs_arg_unset(&state->out_cvalue(m_arg_pos));
     193                 :             :         // The value passed to the function is actually the address of the out
     194                 :             :         // C value
     195                 :         810 :         gjs_arg_set(arg, &state->out_cvalue(m_arg_pos));
     196                 :         810 :         return true;
     197                 :             :     }
     198                 :             : 
     199                 :          76 :     constexpr bool set_inout_parameter(GjsFunctionCallState* state,
     200                 :             :                                        GIArgument* arg) {
     201                 :          76 :         state->out_cvalue(m_arg_pos) = state->inout_original_cvalue(m_arg_pos) =
     202                 :             :             *arg;
     203                 :          76 :         gjs_arg_set(arg, &state->out_cvalue(m_arg_pos));
     204                 :          76 :         return true;
     205                 :             :     }
     206                 :             : 
     207                 :             :     uint8_t m_arg_pos = 0;
     208                 :             : };
     209                 :             : 
     210                 :             : struct ExplicitArray {
     211                 :             :     uint8_t m_length_pos;
     212                 :             :     GIDirection m_length_direction : 2;
     213                 :             : 
     214                 :        1115 :     ExplicitArray(int pos, GIDirection direction)
     215                 :        1115 :         : m_length_pos(pos), m_length_direction(direction) {
     216                 :        1115 :         g_assert(pos >= 0 && pos <= Argument::MAX_ARGS &&
     217                 :             :                  "No more than 253 arguments allowed");
     218                 :        1115 :     }
     219                 :             : };
     220                 :             : 
     221                 :             : struct BasicCArray {
     222                 :         644 :     constexpr explicit BasicCArray(GITypeTag element_tag)
     223                 :         644 :         : m_element_tag(element_tag) {
     224                 :         644 :         g_assert(GI_TYPE_TAG_IS_BASIC(element_tag));
     225                 :         644 :     }
     226                 :             : 
     227                 :             :     GITypeTag m_element_tag;
     228                 :             : };
     229                 :             : 
     230                 :             : struct ZeroTerminatedArray {
     231                 :         339 :     constexpr explicit ZeroTerminatedArray(const GI::TypeInfo) {}
     232                 :             : 
     233                 :          26 :     bool in(JSContext* cx, GITypeTag element_tag, GIArgument* arg,
     234                 :             :             const char* arg_name, GjsArgumentFlags flags,
     235                 :             :             JS::HandleValue value) {
     236                 :          26 :         return gjs_value_to_basic_array_gi_argument(
     237                 :             :             cx, value, element_tag, GI_ARRAY_TYPE_C, arg, arg_name,
     238                 :          26 :             GJS_ARGUMENT_ARGUMENT, flags);
     239                 :             :     }
     240                 :             : 
     241                 :          43 :     bool out(JSContext* cx, GITypeTag element_tag, GIArgument* arg,
     242                 :             :              JS::MutableHandleValue value) {
     243                 :          43 :         return gjs_array_from_basic_zero_terminated_array(
     244                 :          43 :             cx, value, element_tag, gjs_arg_get<void*>(arg));
     245                 :             :     }
     246                 :             : 
     247                 :          45 :     void release_container(GIArgument* arg) {
     248         [ +  - ]:          45 :         g_clear_pointer(&gjs_arg_member<void*>(arg), g_free);
     249                 :          45 :     }
     250                 :             : 
     251                 :          38 :     void release_contents(GIArgument* arg) {
     252                 :          38 :         char** array = gjs_arg_get<char**>(arg);
     253         [ +  + ]:         139 :         for (size_t ix = 0; array[ix]; ix++)
     254                 :         101 :             g_free(array[ix]);
     255                 :          38 :     }
     256                 :             : 
     257                 :          27 :     Maybe<ReturnTag> return_tag() const {
     258                 :          27 :         return Some(ReturnTag{GI_TYPE_TAG_ARRAY});
     259                 :             :     }
     260                 :             : };
     261                 :             : 
     262                 :             : struct GArrayContainer {
     263                 :          19 :     constexpr explicit GArrayContainer(const GI::TypeInfo) {}
     264                 :             : 
     265                 :           8 :     bool in(JSContext* cx, GITypeTag element_tag, GIArgument* arg,
     266                 :             :             const char* arg_name, GjsArgumentFlags flags,
     267                 :             :             JS::HandleValue value) {
     268                 :           8 :         return gjs_value_to_basic_array_gi_argument(
     269                 :             :             cx, value, element_tag, GI_ARRAY_TYPE_ARRAY, arg, arg_name,
     270                 :           8 :             GJS_ARGUMENT_ARGUMENT, flags);
     271                 :             :     }
     272                 :             : 
     273                 :          13 :     bool out(JSContext* cx, GITypeTag element_tag, GIArgument* arg,
     274                 :             :              JS::MutableHandleValue value_out) {
     275                 :          13 :         return gjs_value_from_basic_garray_gi_argument(cx, value_out,
     276                 :          13 :                                                        element_tag, arg);
     277                 :             :     }
     278                 :             : 
     279                 :          11 :     void release_container(GIArgument* arg) {
     280         [ +  - ]:          11 :         g_clear_pointer(&gjs_arg_member<GArray*>(arg), g_array_unref);
     281                 :          11 :     }
     282                 :             : 
     283                 :           4 :     void release_contents(GIArgument* arg) {
     284                 :           4 :         GArray* array = gjs_arg_get<GArray*>(arg);
     285         [ +  + ]:          16 :         for (size_t ix = 0; ix < array->len; ix++)
     286                 :          12 :             g_free(g_array_index(array, char*, ix));
     287                 :           4 :     }
     288                 :             : 
     289                 :           6 :     Maybe<ReturnTag> return_tag() const {
     290                 :           6 :         return Some(ReturnTag{GI_TYPE_TAG_ARRAY});
     291                 :             :     }
     292                 :             : };
     293                 :             : 
     294                 :             : struct GPtrArrayContainer {
     295                 :          14 :     constexpr explicit GPtrArrayContainer(const GI::TypeInfo) {}
     296                 :             : 
     297                 :           3 :     bool in(JSContext* cx, GITypeTag element_tag, GIArgument* arg,
     298                 :             :             const char* arg_name, GjsArgumentFlags flags,
     299                 :             :             JS::HandleValue value) {
     300                 :           3 :         return gjs_value_to_basic_array_gi_argument(
     301                 :             :             cx, value, element_tag, GI_ARRAY_TYPE_PTR_ARRAY, arg, arg_name,
     302                 :           3 :             GJS_ARGUMENT_ARGUMENT, flags);
     303                 :             :     }
     304                 :             : 
     305                 :          12 :     bool out(JSContext* cx, GITypeTag element_tag, GIArgument* arg,
     306                 :             :              JS::MutableHandleValue value_out) {
     307                 :          12 :         return gjs_value_from_basic_gptrarray_gi_argument(cx, value_out,
     308                 :          12 :                                                           element_tag, arg);
     309                 :             :     }
     310                 :             : 
     311                 :           8 :     void release_container(GIArgument* arg) {
     312         [ +  - ]:           8 :         g_clear_pointer(&gjs_arg_member<GPtrArray*>(arg), g_ptr_array_unref);
     313                 :           8 :     }
     314                 :             : 
     315                 :           5 :     void release_contents(GIArgument* arg) {
     316                 :           5 :         GPtrArray* array = gjs_arg_get<GPtrArray*>(arg);
     317                 :           5 :         g_ptr_array_foreach(
     318                 :          13 :             array, [](void* ptr, void*) { g_free(ptr); }, nullptr);
     319                 :           5 :     }
     320                 :             : 
     321                 :           5 :     Maybe<ReturnTag> return_tag() const {
     322                 :           5 :         return Some(ReturnTag{GI_TYPE_TAG_ARRAY});
     323                 :             :     }
     324                 :             : };
     325                 :             : 
     326                 :             : struct FixedSizeArray {
     327                 :          26 :     explicit FixedSizeArray(const GI::TypeInfo type_info) {
     328                 :          26 :         size_t fixed_size = type_info.array_fixed_size().value();
     329                 :          26 :         g_assert(
     330                 :             :             fixed_size <= UINT32_MAX &&
     331                 :             :             "4294967295 fixed array elements ought to be enough for anybody");
     332                 :          26 :         m_fixed_size = fixed_size;
     333                 :          26 :     }
     334                 :             : 
     335                 :             :     uint32_t m_fixed_size = -1;
     336                 :             : 
     337                 :          10 :     bool in(JSContext* cx, GITypeTag element_tag, GIArgument* arg,
     338                 :             :             const char* arg_name, GjsArgumentFlags flags,
     339                 :             :             JS::HandleValue value) {
     340                 :          10 :         return gjs_value_to_basic_array_gi_argument(
     341                 :             :             cx, value, element_tag, GI_ARRAY_TYPE_C, arg, arg_name,
     342                 :          10 :             GJS_ARGUMENT_ARGUMENT, flags);
     343                 :             :     }
     344                 :             : 
     345                 :          17 :     bool out(JSContext* cx, GITypeTag element_tag, GIArgument* arg,
     346                 :             :              JS::MutableHandleValue value) {
     347                 :          17 :         return gjs_value_from_basic_fixed_size_array_gi_argument(
     348                 :          17 :             cx, value, element_tag, m_fixed_size, arg);
     349                 :             :     }
     350                 :             : 
     351                 :          15 :     void release_container(GIArgument* arg) {
     352         [ +  - ]:          15 :         g_clear_pointer(&gjs_arg_member<void*>(arg), g_free);
     353                 :          15 :     }
     354                 :             : 
     355                 :           5 :     void release_contents(GIArgument* arg) {
     356                 :           5 :         char** array = gjs_arg_get<char**>(arg);
     357         [ +  + ]:          25 :         for (size_t ix = 0; ix < m_fixed_size; ix++)
     358                 :          20 :             g_free(array[ix]);
     359                 :           5 :     }
     360                 :             : 
     361                 :           7 :     Maybe<ReturnTag> return_tag() const {
     362                 :           7 :         return Some(ReturnTag{GI_TYPE_TAG_ARRAY});
     363                 :             :     }
     364                 :             : };
     365                 :             : 
     366                 :             : struct GListContainer {
     367                 :          50 :     explicit GListContainer(const GI::TypeInfo type_info)
     368                 :          50 :         : m_double_link(type_info.tag() == GI_TYPE_TAG_GLIST) {}
     369                 :             :     bool m_double_link : 1;
     370                 :             : 
     371                 :          16 :     bool in(JSContext* cx, GITypeTag element_tag, GIArgument* arg,
     372                 :             :             const char* arg_name, GjsArgumentFlags, JS::HandleValue value) {
     373         [ +  + ]:          16 :         if (m_double_link) {
     374                 :           8 :             return gjs_value_to_basic_glist_gi_argument(
     375                 :           8 :                 cx, value, element_tag, arg, arg_name, GJS_ARGUMENT_ARGUMENT);
     376                 :             :         }
     377                 :           8 :         return gjs_value_to_basic_gslist_gi_argument(
     378                 :           8 :             cx, value, element_tag, arg, arg_name, GJS_ARGUMENT_ARGUMENT);
     379                 :             :     }
     380                 :             : 
     381                 :          36 :     bool out(JSContext* cx, GITypeTag element_tag, GIArgument* arg,
     382                 :             :              JS::MutableHandleValue value) {
     383         [ +  + ]:          36 :         if (m_double_link)
     384                 :          17 :             return gjs_array_from_basic_glist_gi_argument(cx, value,
     385                 :          17 :                                                           element_tag, arg);
     386                 :          19 :         return gjs_array_from_basic_gslist_gi_argument(cx, value, element_tag,
     387                 :          19 :                                                        arg);
     388                 :             :     }
     389                 :             : 
     390                 :          25 :     void release_container(GIArgument* arg) {
     391         [ +  + ]:          25 :         if (m_double_link)
     392         [ +  - ]:          13 :             g_clear_pointer(&gjs_arg_member<GList*>(arg), g_list_free);
     393                 :             :         else
     394         [ +  - ]:          12 :             g_clear_pointer(&gjs_arg_member<GSList*>(arg), g_slist_free);
     395                 :          25 :     }
     396                 :             : 
     397                 :          16 :     void release_contents(GIArgument* arg) {
     398                 :          46 :         GFunc free_gfunc = [](void* data, void*) { g_free(data); };
     399                 :             : 
     400         [ +  + ]:          16 :         if (m_double_link) {
     401                 :           8 :             GList* list = gjs_arg_get<GList*>(arg);
     402                 :           8 :             g_list_foreach(list, free_gfunc, nullptr);
     403                 :             :         } else {
     404                 :           8 :             GSList* list = gjs_arg_get<GSList*>(arg);
     405                 :           8 :             g_slist_foreach(list, free_gfunc, nullptr);
     406                 :             :         }
     407                 :          16 :     }
     408                 :             : 
     409                 :          20 :     Maybe<ReturnTag> return_tag() const {
     410                 :          20 :         return Some(ReturnTag{container_tag()});
     411                 :             :     }
     412                 :          20 :     constexpr GITypeTag container_tag() const {
     413         [ +  + ]:          20 :         return m_double_link ? GI_TYPE_TAG_GLIST : GI_TYPE_TAG_GSLIST;
     414                 :             :     }
     415                 :             : };
     416                 :             : 
     417                 :             : struct GHashContainer {
     418                 :          31 :     explicit GHashContainer(const GI::TypeInfo type_info)
     419                 :          31 :         : m_value_tag(type_info.value_type().tag()) {}
     420                 :             :     constexpr GITypeTag value_tag() const { return m_value_tag; }
     421                 :             : 
     422                 :             :     // Key type is managed by the basic container
     423                 :             :     GITypeTag m_value_tag;
     424                 :             : };
     425                 :             : 
     426                 :             : template <GI::InfoTag TAG>
     427                 :             : struct HasIntrospectionInfo {
     428                 :        1557 :     constexpr explicit HasIntrospectionInfo(const GI::UnownedInfo<TAG>& info)
     429                 :        1557 :         : m_info(info) {}
     430                 :             : 
     431                 :             :     GI::OwnedInfo<TAG> m_info;
     432                 :             : };
     433                 :             : 
     434                 :             : // boxed / union / GObject
     435                 :             : struct GTypedType {
     436                 :        7242 :     explicit GTypedType(GType gtype) : m_gtype(gtype) {}
     437                 :      109138 :     constexpr GType gtype() const { return m_gtype; }
     438                 :             : 
     439                 :             :  protected:
     440                 :             :     GType m_gtype;
     441                 :             : };
     442                 :             : 
     443                 :             : struct RegisteredType : GTypedType {
     444                 :           8 :     RegisteredType(GType gtype, GIInfoType info_type)
     445                 :           8 :         : GTypedType(gtype), m_info_type(info_type) {}
     446                 :        6735 :     explicit RegisteredType(const GI::RegisteredTypeInfo info)
     447                 :        6735 :         : GTypedType(info.gtype()), m_info_type(info.type()) {
     448                 :        6735 :         g_assert(m_gtype != G_TYPE_NONE &&
     449                 :             :                  "Use RegisteredInterface for this type");
     450                 :        6735 :     }
     451                 :             : 
     452                 :             :     Maybe<ReturnTag> return_tag() const {
     453                 :             :         return Some(ReturnTag{GI_TYPE_TAG_INTERFACE, m_info_type, true});
     454                 :             :     }
     455                 :             : 
     456                 :             :     GIInfoType m_info_type : 5;
     457                 :             : };
     458                 :             : 
     459                 :             : template <GI::InfoTag TAG>
     460                 :             : struct RegisteredInterface : HasIntrospectionInfo<TAG>, GTypedType {
     461                 :         489 :     explicit RegisteredInterface(const GI::UnownedInfo<TAG> info)
     462                 :         489 :         : HasIntrospectionInfo<TAG>(info), GTypedType(info.gtype()) {}
     463                 :             : 
     464                 :             :     Maybe<ReturnTag> return_tag() const {
     465                 :             :         return Some(ReturnTag{GI_TYPE_TAG_INTERFACE,
     466                 :             :                               HasIntrospectionInfo<TAG>::m_info.type(), true});
     467                 :             :     }
     468                 :             : };
     469                 :             : 
     470                 :             : struct Callback : Nullable, HasIntrospectionInfo<GI::InfoTag::CALLBACK> {
     471                 :        1060 :     explicit Callback(const GI::CallbackInfo info, Maybe<unsigned> closure_pos,
     472                 :             :                       Maybe<unsigned> destroy_pos, GIScopeType scope)
     473                 :        1060 :         : HasIntrospectionInfo(info),
     474                 :        1060 :           m_closure_pos(closure_pos.valueOr(Argument::ABSENT)),
     475                 :        1060 :           m_destroy_pos(destroy_pos.valueOr(Argument::ABSENT)),
     476                 :        1060 :           m_scope(scope) {
     477                 :        1060 :         g_assert(destroy_pos.valueOr(0) <= Argument::MAX_ARGS &&
     478                 :             :                  "No more than 253 arguments allowed");
     479                 :        1060 :         g_assert(closure_pos.valueOr(0) <= Argument::MAX_ARGS &&
     480                 :             :                  "No more than 253 arguments allowed");
     481                 :        1060 :     }
     482                 :             : 
     483                 :         520 :     [[nodiscard]] constexpr bool has_callback_destroy() {
     484                 :         520 :         return m_destroy_pos != Argument::ABSENT;
     485                 :             :     }
     486                 :             : 
     487                 :         260 :     [[nodiscard]] constexpr bool has_callback_closure() {
     488                 :         260 :         return m_closure_pos != Argument::ABSENT;
     489                 :             :     }
     490                 :             : 
     491                 :             :     uint8_t m_closure_pos;
     492                 :             :     uint8_t m_destroy_pos;
     493                 :             :     GIScopeType m_scope : 3;
     494                 :             : };
     495                 :             : 
     496                 :             : struct Enum {
     497                 :             :     explicit Enum(const GI::EnumInfo);
     498                 :             :     bool m_unsigned : 1;
     499                 :             :     uint32_t m_min = 0;
     500                 :             :     uint32_t m_max = 0;
     501                 :             : };
     502                 :             : 
     503                 :             : struct Flags {
     504                 :             :     explicit Flags(const GI::FlagsInfo);
     505                 :             :     unsigned m_mask = 0;
     506                 :             : };
     507                 :             : 
     508                 :             : struct CallerAllocates {
     509                 :          16 :     explicit CallerAllocates(size_t size) : m_allocates_size(size) {}
     510                 :             :     size_t m_allocates_size;
     511                 :             : };
     512                 :             : 
     513                 :             : // Gjs::Arguments:
     514                 :             : //
     515                 :             : // Each argument, irrespective of the direction, is processed in three phases:
     516                 :             : // - before calling the function [in]
     517                 :             : // - after calling it, when converting the return value and out arguments [out]
     518                 :             : // - at the end of the invocation, to release any allocated memory [release]
     519                 :             : //
     520                 :             : // Some types don't have direction (for example, caller_allocates is only out,
     521                 :             : // and callback is only in), in which case it is implied.
     522                 :             : 
     523                 :             : struct SkipAll : Argument {
     524                 :         699 :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     525                 :             :             JS::HandleValue) override {
     526                 :         699 :         return skip();
     527                 :             :     }
     528                 :             : 
     529                 :       80659 :     bool out(JSContext*, GjsFunctionCallState*, GIArgument*,
     530                 :             :              JS::MutableHandleValue) override {
     531                 :       80659 :         return skip();
     532                 :             :     }
     533                 :             : 
     534                 :       50801 :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     535                 :             :                  GIArgument*) override {
     536                 :       50801 :         return skip();
     537                 :             :     }
     538                 :             : 
     539                 :             :  protected:
     540                 :      200417 :     constexpr bool skip() { return true; }
     541                 :             : };
     542                 :             : 
     543                 :             : struct Fallback : Transferable, HasTypeInfo {
     544                 :             :     using HasTypeInfo::HasTypeInfo;
     545                 :             : };
     546                 :             : 
     547                 :             : struct FallbackIn : SkipAll, Fallback, Nullable {
     548                 :             :     using Fallback::Fallback;
     549                 :             : 
     550                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     551                 :             :             JS::HandleValue) override;
     552                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     553                 :             :                  GIArgument*) override;
     554                 :             : 
     555                 :           5 :     GjsArgumentFlags flags() const override {
     556                 :           5 :         return Argument::flags() | Nullable::flags();
     557                 :             :     }
     558                 :             : };
     559                 :             : 
     560                 :             : struct FallbackInOut : SkipAll, Positioned, Fallback {
     561                 :             :     using Fallback::Fallback;
     562                 :             : 
     563                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     564                 :             :             JS::HandleValue) override;
     565                 :             :     bool out(JSContext*, GjsFunctionCallState*, GIArgument*,
     566                 :             :              JS::MutableHandleValue) override;
     567                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     568                 :             :                  GIArgument*) override;
     569                 :             : };
     570                 :             : 
     571                 :             : struct FallbackOut : FallbackInOut {
     572                 :             :     using FallbackInOut::FallbackInOut;
     573                 :             : 
     574                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
     575                 :             :             JS::HandleValue) override;
     576                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
     577                 :             :                  GIArgument*) override;
     578                 :             : };
     579                 :             : 
     580                 :             : struct FallbackReturn : FallbackOut {
     581                 :             :     using FallbackOut::FallbackOut;
     582                 :             :     // No in!
     583                 :           0 :     bool in(JSContext* cx, GjsFunctionCallState*, GIArgument*,
     584                 :             :             JS::HandleValue) override {
     585                 :           0 :         return invalid(cx, G_STRFUNC);
     586                 :             :     }
     587                 :             : 
     588                 :       21580 :     Maybe<ReturnTag> return_tag() const override {
     589                 :       21580 :         return HasTypeInfo::return_tag();
     590                 :             :     }
     591                 :             : };
     592                 :             : 
     593                 :             : template <typename TAG>
     594                 :             : struct NumericOut : SkipAll, Positioned {
     595                 :             :     static_assert(std::is_arithmetic_v<Tag::RealT<TAG>>, "Not arithmetic type");
     596                 :         546 :     bool in(JSContext*, GjsFunctionCallState* state, GIArgument* arg,
     597                 :             :             JS::HandleValue) override {
     598                 :         546 :         return set_out_parameter(state, arg);
     599                 :             :     }
     600                 :         546 :     bool out(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
     601                 :             :              JS::MutableHandleValue value) override {
     602                 :         546 :         return Gjs::c_value_to_js_checked<TAG>(cx, gjs_arg_get<TAG>(arg),
     603                 :         546 :                                                value);
     604                 :             :     }
     605                 :             : };
     606                 :             : 
     607                 :             : using BooleanOut = NumericOut<Tag::GBoolean>;
     608                 :             : 
     609                 :             : template <typename TAG>
     610                 :             : struct NumericReturn : SkipAll {
     611                 :             :     static_assert(std::is_arithmetic_v<Tag::RealT<TAG>>, "Not arithmetic type");
     612                 :           0 :     bool in(JSContext* cx, GjsFunctionCallState*, GIArgument*,
     613                 :             :             JS::HandleValue) override {
     614                 :           0 :         return invalid(cx, G_STRFUNC);
     615                 :             :     }
     616                 :       15725 :     bool out(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
     617                 :             :              JS::MutableHandleValue value) override {
     618                 :       15725 :         return Gjs::c_value_to_js_checked<TAG>(cx, gjs_arg_get<TAG>(arg),
     619                 :       15725 :                                                value);
     620                 :             :     }
     621                 :       15725 :     Maybe<ReturnTag> return_tag() const override {
     622                 :       15725 :         return Some(ReturnTag{MarshallingInfo<TAG>::gi_tag});
     623                 :             :     }
     624                 :             : };
     625                 :             : 
     626                 :             : using BooleanReturn = NumericReturn<Tag::GBoolean>;
     627                 :             : 
     628                 :             : struct SimpleOut : SkipAll, Positioned {
     629                 :          39 :     bool in(JSContext*, GjsFunctionCallState* state, GIArgument* arg,
     630                 :             :             JS::HandleValue) override {
     631                 :          39 :         return set_out_parameter(state, arg);
     632                 :             :     };
     633                 :             : };
     634                 :             : 
     635                 :             : struct BasicTypeReturn : SkipAll, BasicType {
     636                 :             :     using BasicType::BasicType;
     637                 :             : 
     638                 :           0 :     bool in(JSContext* cx, GjsFunctionCallState*, GIArgument*,
     639                 :             :             JS::HandleValue) override {
     640                 :           0 :         return invalid(cx, G_STRFUNC);
     641                 :             :     }
     642                 :        1539 :     bool out(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
     643                 :             :              JS::MutableHandleValue value) override {
     644                 :        1539 :         return gjs_value_from_basic_gi_argument(cx, value, m_tag, arg);
     645                 :             :     }
     646                 :        1516 :     bool release(JSContext*, GjsFunctionCallState*,
     647                 :             :                  GIArgument* in_arg [[maybe_unused]],
     648                 :             :                  GIArgument* out_arg) override {
     649                 :        1516 :         gjs_gi_argument_release_basic(GI_TRANSFER_NOTHING, m_tag,
     650                 :             :                                       Argument::flags(), out_arg);
     651                 :        1516 :         return true;
     652                 :             :     }
     653                 :             : 
     654                 :        1524 :     Maybe<ReturnTag> return_tag() const override {
     655                 :        1524 :         return Some(ReturnTag{m_tag});
     656                 :             :     }
     657                 :             : };
     658                 :             : 
     659                 :             : struct BasicTypeOut : BasicTypeReturn, Positioned {
     660                 :             :     using BasicTypeReturn::BasicTypeReturn;
     661                 :             : 
     662                 :           0 :     bool in(JSContext*, GjsFunctionCallState* state, GIArgument* arg,
     663                 :             :             JS::HandleValue) override {
     664                 :           0 :         return set_out_parameter(state, arg);
     665                 :             :     }
     666                 :             : };
     667                 :             : 
     668                 :             : struct BasicTypeInOut : BasicTypeOut {
     669                 :             :     using BasicTypeOut::BasicTypeOut;
     670                 :           4 :     bool in(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
     671                 :             :             JS::HandleValue value) override {
     672         [ -  + ]:           4 :         if (!gjs_value_to_basic_gi_argument(cx, value, m_tag, arg, arg_name(),
     673                 :           4 :                                             GJS_ARGUMENT_ARGUMENT, flags()))
     674                 :           0 :             return false;
     675                 :             : 
     676                 :           4 :         return set_inout_parameter(state, arg);
     677                 :             :     }
     678                 :           4 :     bool release(JSContext*, GjsFunctionCallState* state,
     679                 :             :                  GIArgument* in_arg [[maybe_unused]],
     680                 :             :                  GIArgument* out_arg [[maybe_unused]]) override {
     681                 :             :         GIArgument* original_out_arg =
     682                 :           4 :             &(state->inout_original_cvalue(m_arg_pos));
     683                 :           4 :         gjs_gi_argument_release_basic(GI_TRANSFER_NOTHING, m_tag, flags(),
     684                 :             :                                       original_out_arg);
     685                 :           4 :         return true;
     686                 :             :     }
     687                 :             : };
     688                 :             : 
     689                 :             : struct BasicTypeTransferableReturn : BasicTypeReturn, Transferable {
     690                 :             :     using BasicTypeReturn::BasicTypeReturn;
     691                 :          19 :     bool release(JSContext*, GjsFunctionCallState*,
     692                 :             :                  GIArgument* in_arg [[maybe_unused]],
     693                 :             :                  GIArgument* out_arg) override {
     694                 :          19 :         gjs_gi_argument_release_basic(m_transfer, m_tag, Argument::flags(),
     695                 :             :                                       out_arg);
     696                 :          19 :         return true;
     697                 :             :     }
     698                 :             : };
     699                 :             : 
     700                 :             : struct BasicTypeTransferableOut : BasicTypeTransferableReturn, Positioned {
     701                 :             :     using BasicTypeTransferableReturn::BasicTypeTransferableReturn;
     702                 :             : 
     703                 :          11 :     bool in(JSContext*, GjsFunctionCallState* state, GIArgument* arg,
     704                 :             :             JS::HandleValue) override {
     705                 :          11 :         return set_out_parameter(state, arg);
     706                 :             :     }
     707                 :             : };
     708                 :             : 
     709                 :             : struct BasicTypeTransferableInOut : BasicTypeInOut, Transferable {
     710                 :             :     using BasicTypeInOut::BasicTypeInOut;
     711                 :             : 
     712                 :           3 :     bool release(JSContext* cx, GjsFunctionCallState* state, GIArgument* in_arg,
     713                 :             :                  GIArgument* out_arg) override {
     714         [ -  + ]:           3 :         if (!BasicTypeInOut::release(cx, state, in_arg, out_arg))
     715                 :           0 :             return false;
     716                 :             : 
     717         [ +  - ]:           3 :         if (m_transfer != GI_TRANSFER_NOTHING)
     718                 :           3 :             gjs_gi_argument_release_basic(m_transfer, m_tag, flags(), out_arg);
     719                 :             : 
     720                 :           3 :         return true;
     721                 :             :     }
     722                 :             : };
     723                 :             : 
     724                 :             : struct ErrorIn : SkipAll, Transferable, Nullable {
     725                 :           4 :     bool in(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
     726                 :             :             JS::HandleValue value) override {
     727                 :           4 :         return gjs_value_to_gerror_gi_argument(cx, value, m_transfer, arg,
     728                 :             :                                                m_arg_name,
     729                 :           8 :                                                GJS_ARGUMENT_ARGUMENT, flags());
     730                 :             :     }
     731                 :             : 
     732                 :           4 :     GjsArgumentFlags flags() const override {
     733                 :           4 :         return Argument::flags() | Nullable::flags();
     734                 :             :     }
     735                 :             : };
     736                 :             : 
     737                 :             : // The tag is normally used in containers for the element type, but for explicit
     738                 :             : // arrays we use it for the length argument type. Specific implementations can
     739                 :             : // override this
     740                 :             : struct BasicTypeContainerReturn : BasicTypeTransferableReturn, Nullable {
     741                 :        1563 :     explicit BasicTypeContainerReturn(GITypeTag element_tag)
     742                 :        1563 :         : BasicTypeTransferableReturn(element_tag) {}
     743                 :             : 
     744                 :         448 :     explicit BasicTypeContainerReturn(const GI::TypeInfo type_info)
     745                 :         448 :         : BasicTypeContainerReturn(type_info.element_type().tag()) {}
     746                 :             : 
     747                 :         428 :     GjsArgumentFlags flags() const override {
     748                 :         428 :         return Argument::flags() | Nullable::flags();
     749                 :             :     }
     750                 :           0 :     Maybe<ReturnTag> return_tag() const override {
     751                 :             :         // in Return subclasses, this must be overridden with the container tag
     752                 :             :         g_return_val_if_reached(Nothing{});
     753                 :             :     }
     754                 :         352 :     constexpr GITypeTag element_tag() { return m_tag; }
     755                 :             : };
     756                 :             : 
     757                 :             : struct BasicTypeContainerOut : BasicTypeContainerReturn, Positioned {
     758                 :             :     using BasicTypeContainerReturn::BasicTypeContainerReturn;
     759                 :             : };
     760                 :             : 
     761                 :             : struct BasicTypeContainerIn : BasicTypeContainerReturn {
     762                 :             :     using BasicTypeContainerReturn::BasicTypeContainerReturn;
     763                 :             : 
     764                 :           0 :     bool out(JSContext*, GjsFunctionCallState*, GIArgument*,
     765                 :             :              JS::MutableHandleValue) override {
     766                 :           0 :         return skip();
     767                 :             :     }
     768                 :             : };
     769                 :             : 
     770                 :             : struct BasicTypeContainerInOut : BasicTypeContainerOut {
     771                 :             :     using BasicTypeContainerOut::BasicTypeContainerOut;
     772                 :             : };
     773                 :             : 
     774                 :             : template <class Marshaller, class Container>
     775                 :             : struct BasicTypeContainer : Marshaller, Container {
     776                 :         448 :     explicit BasicTypeContainer(const GI::TypeInfo type_info)
     777                 :         448 :         : Marshaller(type_info), Container(type_info) {}
     778                 :             : 
     779                 :         107 :     bool in(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
     780                 :             :             JS::HandleValue value) override {
     781                 :             :         if constexpr (std::is_same_v<Marshaller, BasicTypeContainerIn>) {
     782                 :          51 :             return Container::in(cx, Marshaller::element_tag(), arg,
     783                 :             :                                  Marshaller::arg_name(), Marshaller::flags(),
     784                 :          51 :                                  value);
     785                 :             :         }
     786                 :             :         if constexpr (std::is_same_v<Marshaller, BasicTypeContainerReturn>)
     787                 :           0 :             return Marshaller::invalid(cx, G_STRFUNC);
     788                 :             :         if constexpr (std::is_same_v<Marshaller, BasicTypeContainerOut>)
     789                 :          44 :             return Marshaller::set_out_parameter(state, arg);
     790                 :             :         if constexpr (std::is_same_v<Marshaller, BasicTypeContainerInOut>) {
     791                 :          12 :             return Container::in(cx, Marshaller::element_tag(), arg,
     792                 :             :                                  Marshaller::arg_name(), Marshaller::flags(),
     793   [ +  -  +  - ]:          24 :                                  value) &&
     794                 :          24 :                    Marshaller::set_inout_parameter(state, arg);
     795                 :             :         }
     796                 :             :         g_return_val_if_reached(false);
     797                 :             :     }
     798                 :             : 
     799                 :         168 :     bool out(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
     800                 :             :              JS::MutableHandleValue value) override {
     801                 :             :         if constexpr (std::is_same_v<Marshaller, BasicTypeContainerIn>)
     802                 :          47 :             return Marshaller::skip();
     803                 :             :         if constexpr (std::is_same_v<Marshaller, BasicTypeContainerReturn> ||
     804                 :             :                       std::is_same_v<Marshaller, BasicTypeContainerOut> ||
     805                 :             :                       std::is_same_v<Marshaller, BasicTypeContainerInOut>) {
     806                 :         121 :             return Container::out(cx, Marshaller::element_tag(), arg, value);
     807                 :             :         }
     808                 :             :         g_return_val_if_reached(false);
     809                 :             :     }
     810                 :         168 :     bool release(JSContext*, GjsFunctionCallState* state, GIArgument* in_arg,
     811                 :             :                  GIArgument* out_arg) override {
     812                 :         168 :         GITransfer transfer = Marshaller::m_transfer;
     813                 :         168 :         GITypeTag element_tag = Marshaller::element_tag();
     814                 :             : 
     815                 :             :         if constexpr (std::is_same_v<Marshaller, BasicTypeContainerIn>) {
     816         [ +  + ]:          47 :             if (!state->call_completed())
     817                 :           1 :                 transfer = GI_TRANSFER_NOTHING;
     818                 :             : 
     819   [ +  +  +  +  :          47 :             if (!gjs_arg_get<void*>(in_arg) ||
                   +  + ]
     820                 :             :                 transfer == GI_TRANSFER_EVERYTHING)
     821                 :           9 :                 return true;
     822                 :             : 
     823         [ +  + ]:          38 :             if (Gjs::basic_type_needs_release(element_tag))
     824                 :          23 :                 Container::release_contents(in_arg);
     825         [ +  + ]:          38 :             if (transfer != GI_TRANSFER_CONTAINER)
     826                 :          37 :                 Container::release_container(in_arg);
     827                 :             : 
     828                 :          38 :             return true;
     829                 :             :         }
     830                 :             :         if constexpr (std::is_same_v<Marshaller, BasicTypeContainerInOut>) {
     831         [ -  + ]:          12 :             if (!state->call_completed())
     832                 :           0 :                 transfer = GI_TRANSFER_NOTHING;
     833                 :             : 
     834                 :             :             GIArgument* original_out_arg =
     835                 :          12 :                 &(state->inout_original_cvalue(Marshaller::m_arg_pos));
     836                 :          12 :             void* original_out_ptr = gjs_arg_get<void*>(original_out_arg);
     837         [ +  + ]:          12 :             if (original_out_ptr &&
     838   [ +  -  +  +  :          24 :                 original_out_ptr != gjs_arg_get<void*>(out_arg) &&
                   +  + ]
     839                 :             :                 transfer != GI_TRANSFER_EVERYTHING) {
     840         [ +  + ]:           9 :                 if (Gjs::basic_type_needs_release(element_tag))
     841                 :           8 :                     Container::release_contents(original_out_arg);
     842         [ +  - ]:           9 :                 if (transfer != GI_TRANSFER_CONTAINER)
     843                 :           9 :                     Container::release_container(original_out_arg);
     844                 :             :             }
     845                 :             :         }
     846                 :             :         if constexpr (std::is_same_v<Marshaller, BasicTypeContainerReturn> ||
     847                 :             :                       std::is_same_v<Marshaller, BasicTypeContainerOut> ||
     848                 :             :                       std::is_same_v<Marshaller, BasicTypeContainerInOut>) {
     849   [ +  +  +  +  :         121 :             if (!gjs_arg_get<void*>(out_arg) || transfer == GI_TRANSFER_NOTHING)
                   +  + ]
     850                 :          63 :                 return true;
     851                 :             : 
     852   [ +  +  +  +  :          58 :             if (Gjs::basic_type_needs_release(element_tag) &&
                   +  + ]
     853                 :             :                 transfer != GI_TRANSFER_CONTAINER)
     854                 :          37 :                 Container::release_contents(out_arg);
     855                 :          58 :             Container::release_container(out_arg);
     856                 :             : 
     857                 :          58 :             return true;
     858                 :             :         }
     859                 :             :         g_return_val_if_reached(false);
     860                 :             :     }
     861                 :             : 
     862                 :          65 :     Maybe<ReturnTag> return_tag() const override {
     863                 :          65 :         return Container::return_tag();
     864                 :             :     }
     865                 :             : };
     866                 :             : 
     867                 :             : using BasicGListReturn =
     868                 :             :     BasicTypeContainer<BasicTypeContainerReturn, GListContainer>;
     869                 :             : using BasicGListIn = BasicTypeContainer<BasicTypeContainerIn, GListContainer>;
     870                 :             : using BasicGListOut = BasicTypeContainer<BasicTypeContainerOut, GListContainer>;
     871                 :             : using BasicGListInOut =
     872                 :             :     BasicTypeContainer<BasicTypeContainerInOut, GListContainer>;
     873                 :             : 
     874                 :             : using BasicCZeroTerminatedArrayReturn =
     875                 :             :     BasicTypeContainer<BasicTypeContainerReturn, ZeroTerminatedArray>;
     876                 :             : using BasicCZeroTerminatedArrayIn =
     877                 :             :     BasicTypeContainer<BasicTypeContainerIn, ZeroTerminatedArray>;
     878                 :             : using BasicCZeroTerminatedArrayOut =
     879                 :             :     BasicTypeContainer<BasicTypeContainerOut, ZeroTerminatedArray>;
     880                 :             : using BasicCZeroTerminatedArrayInOut =
     881                 :             :     BasicTypeContainer<BasicTypeContainerInOut, ZeroTerminatedArray>;
     882                 :             : 
     883                 :             : using BasicCFixedSizeArrayReturn =
     884                 :             :     BasicTypeContainer<BasicTypeContainerReturn, FixedSizeArray>;
     885                 :             : using BasicCFixedSizeArrayIn =
     886                 :             :     BasicTypeContainer<BasicTypeContainerIn, FixedSizeArray>;
     887                 :             : using BasicCFixedSizeArrayOut =
     888                 :             :     BasicTypeContainer<BasicTypeContainerOut, FixedSizeArray>;
     889                 :             : using BasicCFixedSizeArrayInOut =
     890                 :             :     BasicTypeContainer<BasicTypeContainerInOut, FixedSizeArray>;
     891                 :             : 
     892                 :             : using BasicGArrayReturn =
     893                 :             :     BasicTypeContainer<BasicTypeContainerReturn, GArrayContainer>;
     894                 :             : using BasicGArrayIn = BasicTypeContainer<BasicTypeContainerIn, GArrayContainer>;
     895                 :             : using BasicGArrayOut =
     896                 :             :     BasicTypeContainer<BasicTypeContainerOut, GArrayContainer>;
     897                 :             : using BasicGArrayInOut =
     898                 :             :     BasicTypeContainer<BasicTypeContainerInOut, GArrayContainer>;
     899                 :             : 
     900                 :             : using BasicGPtrArrayReturn =
     901                 :             :     BasicTypeContainer<BasicTypeContainerReturn, GPtrArrayContainer>;
     902                 :             : using BasicGPtrArrayIn =
     903                 :             :     BasicTypeContainer<BasicTypeContainerIn, GPtrArrayContainer>;
     904                 :             : using BasicGPtrArrayOut =
     905                 :             :     BasicTypeContainer<BasicTypeContainerOut, GPtrArrayContainer>;
     906                 :             : using BasicGPtrArrayInOut =
     907                 :             :     BasicTypeContainer<BasicTypeContainerInOut, GPtrArrayContainer>;
     908                 :             : 
     909                 :             : struct BasicGHashReturn : BasicTypeTransferableReturn,
     910                 :             :                           GHashContainer,
     911                 :             :                           Nullable {
     912                 :          31 :     explicit BasicGHashReturn(const GI::TypeInfo type_info)
     913                 :          31 :         : BasicTypeTransferableReturn(type_info.key_type().tag()),
     914                 :          62 :           GHashContainer(type_info) {
     915                 :          31 :         g_assert(GI_TYPE_TAG_IS_BASIC(m_value_tag));
     916                 :          31 :     }
     917                 :             : 
     918                 :          19 :     bool out(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
     919                 :             :              JS::MutableHandleValue value) override {
     920                 :          19 :         return gjs_value_from_basic_ghash(cx, value, m_tag, m_value_tag,
     921                 :          19 :                                           gjs_arg_get<GHashTable*>(arg));
     922                 :             :     }
     923                 :          18 :     bool release(JSContext*, GjsFunctionCallState*,
     924                 :             :                  GIArgument* in_arg [[maybe_unused]],
     925                 :             :                  GIArgument* out_arg) override {
     926         [ +  + ]:          18 :         if (m_transfer == GI_TRANSFER_NOTHING)
     927                 :           7 :             return true;
     928                 :             : 
     929                 :             :         gjs_debug_marshal(
     930                 :             :             GJS_DEBUG_GFUNCTION,
     931                 :             :             "Releasing GIArgument ghash out param or return value");
     932                 :             : 
     933                 :          11 :         gjs_gi_argument_release_basic_ghash(m_transfer, m_tag, m_value_tag,
     934                 :             :                                             out_arg);
     935                 :          11 :         return true;
     936                 :             :     }
     937                 :             : 
     938                 :          13 :     GjsArgumentFlags flags() const override {
     939                 :          13 :         return Argument::flags() | Nullable::flags();
     940                 :             :     }
     941                 :          11 :     Maybe<ReturnTag> return_tag() const override {
     942                 :          11 :         return Some(ReturnTag{GI_TYPE_TAG_GHASH});
     943                 :             :     }
     944                 :             : };
     945                 :             : 
     946                 :             : struct BasicGHashIn : BasicGHashReturn {
     947                 :             :     using BasicGHashReturn::BasicGHashReturn;
     948                 :             : 
     949                 :          12 :     bool in(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
     950                 :             :             JS::HandleValue value) override {
     951                 :          24 :         return gjs_value_to_basic_ghash_gi_argument(
     952                 :          12 :             cx, value, m_tag, m_value_tag, m_transfer, arg, m_arg_name,
     953                 :          24 :             GJS_ARGUMENT_ARGUMENT, flags());
     954                 :             :     }
     955                 :          12 :     bool out(JSContext*, GjsFunctionCallState*, GIArgument*,
     956                 :             :              JS::MutableHandleValue) override {
     957                 :          12 :         return skip();
     958                 :             :     }
     959                 :          12 :     bool release(JSContext*, GjsFunctionCallState* state, GIArgument* in_arg,
     960                 :             :                  GIArgument* out_arg [[maybe_unused]]) override {
     961                 :             :         // GI_TRANSFER_EVERYTHING: we don't own the argument anymore.
     962                 :             :         // GI_TRANSFER_CONTAINER: See FIXME in gjs_array_to_g_list(); currently
     963                 :             :         //   an error and we won't get here.
     964   [ +  -  +  +  :          12 :         if (!state->call_completed() || m_transfer != GI_TRANSFER_NOTHING)
                   +  + ]
     965                 :           1 :             return true;
     966                 :             : 
     967                 :             :         gjs_debug_marshal(GJS_DEBUG_GFUNCTION,
     968                 :             :                           "Releasing GIArgument ghash in param");
     969                 :             : 
     970                 :          11 :         gjs_gi_argument_release_basic_ghash(m_transfer, m_tag, m_value_tag,
     971                 :             :                                             in_arg);
     972                 :          11 :         return true;
     973                 :             :     }
     974                 :             : };
     975                 :             : 
     976                 :             : struct BasicGHashOut : BasicGHashReturn, Positioned {
     977                 :             :     using BasicGHashReturn::BasicGHashReturn;
     978                 :             : 
     979                 :           7 :     bool in(JSContext*, GjsFunctionCallState* state, GIArgument* arg,
     980                 :             :             JS::HandleValue) override {
     981                 :           7 :         return set_out_parameter(state, arg);
     982                 :             :     }
     983                 :             : };
     984                 :             : 
     985                 :             : struct BasicGHashInOut : BasicGHashOut {
     986                 :             :     using BasicGHashOut::BasicGHashOut;
     987                 :           1 :     bool in(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
     988                 :             :             JS::HandleValue value) override {
     989         [ -  + ]:           1 :         if (!gjs_value_to_basic_ghash_gi_argument(
     990                 :           1 :                 cx, value, m_tag, m_value_tag, m_transfer, arg, m_arg_name,
     991                 :           1 :                 GJS_ARGUMENT_ARGUMENT, flags()))
     992                 :           0 :             return false;
     993                 :             : 
     994                 :           1 :         return set_inout_parameter(state, arg);
     995                 :             :     }
     996                 :           1 :     bool release(JSContext*, GjsFunctionCallState* state,
     997                 :             :                  GIArgument* in_arg [[maybe_unused]],
     998                 :             :                  GIArgument* out_arg) override {
     999                 :             :         GIArgument* original_out_arg =
    1000                 :           1 :             &(state->inout_original_cvalue(m_arg_pos));
    1001                 :           1 :         gjs_gi_argument_release_basic_ghash(GI_TRANSFER_NOTHING, m_tag,
    1002                 :             :                                             m_value_tag, original_out_arg);
    1003         [ -  + ]:           1 :         if (m_transfer != GI_TRANSFER_NOTHING)
    1004                 :           0 :             gjs_gi_argument_release_basic_ghash(m_transfer, m_tag, m_value_tag,
    1005                 :             :                                                 out_arg);
    1006                 :           1 :         return true;
    1007                 :             :     }
    1008                 :             : };
    1009                 :             : 
    1010                 :             : struct ByteArrayReturn : SkipAll, Transferable {
    1011                 :           0 :     bool in(JSContext* cx, GjsFunctionCallState*, GIArgument*,
    1012                 :             :             JS::HandleValue) override {
    1013                 :           0 :         return invalid(cx, G_STRFUNC);
    1014                 :             :     }
    1015                 :           4 :     bool out(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
    1016                 :             :              JS::MutableHandleValue value) override {
    1017                 :           4 :         return gjs_value_from_byte_array_gi_argument(cx, value, arg);
    1018                 :             :     }
    1019                 :           3 :     bool release(JSContext*, GjsFunctionCallState*,
    1020                 :             :                  GIArgument* in_arg [[maybe_unused]],
    1021                 :             :                  GIArgument* out_arg) override {
    1022         [ +  - ]:           3 :         if (m_transfer != GI_TRANSFER_NOTHING)
    1023                 :           3 :             gjs_gi_argument_release_byte_array(out_arg);
    1024                 :           3 :         return true;
    1025                 :             :     }
    1026                 :             : 
    1027                 :           2 :     Maybe<ReturnTag> return_tag() const override {
    1028                 :           2 :         return Some(ReturnTag{GI_TYPE_TAG_ARRAY});
    1029                 :             :     }
    1030                 :             : };
    1031                 :             : 
    1032                 :             : struct ByteArrayIn : SkipAll, Transferable {
    1033                 :           3 :     bool in(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
    1034                 :             :             JS::HandleValue value) override {
    1035                 :           3 :         return gjs_value_to_byte_array_gi_argument(cx, value, arg, arg_name(),
    1036                 :           6 :                                                    flags());
    1037                 :             :     }
    1038                 :           3 :     bool release(JSContext*, GjsFunctionCallState* state, GIArgument* in_arg,
    1039                 :             :                  GIArgument* out_arg [[maybe_unused]]) override {
    1040   [ +  -  -  +  :           3 :         if (!state->call_completed() || m_transfer != GI_TRANSFER_NOTHING)
                   -  + ]
    1041                 :           0 :             return true;
    1042                 :             : 
    1043                 :           3 :         gjs_gi_argument_release_byte_array(in_arg);
    1044                 :           3 :         return true;
    1045                 :             :     }
    1046                 :             : };
    1047                 :             : 
    1048                 :             : struct ByteArrayOut : ByteArrayReturn, Positioned {
    1049                 :             :     using ByteArrayReturn::ByteArrayReturn;
    1050                 :             : 
    1051                 :           1 :     bool in(JSContext*, GjsFunctionCallState* state, GIArgument* arg,
    1052                 :             :             JS::HandleValue) override {
    1053                 :           1 :         return set_out_parameter(state, arg);
    1054                 :             :     }
    1055                 :             : };
    1056                 :             : 
    1057                 :             : struct ByteArrayInOut : ByteArrayOut {
    1058                 :             :     using ByteArrayOut::ByteArrayOut;
    1059                 :           1 :     bool in(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
    1060                 :             :             JS::HandleValue value) override {
    1061                 :           1 :         return gjs_value_to_byte_array_gi_argument(cx, value, arg, m_arg_name,
    1062   [ +  -  +  - ]:           3 :                                                    flags()) &&
    1063                 :           2 :                set_inout_parameter(state, arg);
    1064                 :             :     }
    1065                 :           1 :     bool release(JSContext*, GjsFunctionCallState* state,
    1066                 :             :                  GIArgument* in_arg [[maybe_unused]],
    1067                 :             :                  GIArgument* out_arg) override {
    1068                 :             :         GIArgument* original_out_arg =
    1069                 :           1 :             &(state->inout_original_cvalue(m_arg_pos));
    1070         [ -  + ]:           1 :         if (m_transfer != GI_TRANSFER_EVERYTHING)
    1071                 :           0 :             gjs_gi_argument_release_byte_array(original_out_arg);
    1072         [ +  - ]:           1 :         if (m_transfer != GI_TRANSFER_NOTHING)
    1073                 :           1 :             gjs_gi_argument_release_byte_array(out_arg);
    1074                 :           1 :         return true;
    1075                 :             :     }
    1076                 :             : };
    1077                 :             : 
    1078                 :             : struct ExplicitArrayBase : BasicTypeContainerReturn, ExplicitArray {
    1079                 :        1115 :     ExplicitArrayBase(unsigned length_pos, GITypeTag length_tag,
    1080                 :             :                       GIDirection length_direction)
    1081                 :        1115 :         : BasicTypeContainerReturn(length_tag),
    1082                 :        1115 :           ExplicitArray(length_pos, length_direction) {}
    1083                 :             : };
    1084                 :             : 
    1085                 :             : struct CArrayIn : ExplicitArrayBase, HasTypeInfo {
    1086                 :         322 :     CArrayIn(const GI::TypeInfo type_info, unsigned length_pos,
    1087                 :             :              GITypeTag length_tag, GIDirection length_direction)
    1088                 :         322 :         : ExplicitArrayBase(length_pos, length_tag, length_direction),
    1089                 :         322 :           HasTypeInfo(type_info) {}
    1090                 :             : 
    1091                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1092                 :             :             JS::HandleValue) override;
    1093                 :         244 :     bool out(JSContext*, GjsFunctionCallState*, GIArgument*,
    1094                 :             :              JS::MutableHandleValue) override {
    1095                 :         244 :         return skip();
    1096                 :             :     };
    1097                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
    1098                 :             :                  GIArgument*) override;
    1099                 :             : };
    1100                 :             : 
    1101                 :             : // Positioned must come before HasTypeInfo for struct packing reasons, otherwise
    1102                 :             : // this could inherit from CArrayIn
    1103                 :             : struct CArrayInOut : ExplicitArrayBase, Positioned, HasTypeInfo {
    1104                 :         149 :     CArrayInOut(const GI::TypeInfo type_info, unsigned length_pos,
    1105                 :             :                 GITypeTag length_tag, GIDirection length_direction)
    1106                 :         149 :         : ExplicitArrayBase(length_pos, length_tag, length_direction),
    1107                 :         149 :           HasTypeInfo(type_info) {}
    1108                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1109                 :             :             JS::HandleValue) override;
    1110                 :             :     bool out(JSContext*, GjsFunctionCallState*, GIArgument*,
    1111                 :             :              JS::MutableHandleValue) override;
    1112                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
    1113                 :             :                  GIArgument*) override;
    1114                 :             : };
    1115                 :             : 
    1116                 :             : struct CArrayOut : CArrayInOut {
    1117                 :             :     using CArrayInOut::CArrayInOut;
    1118                 :             : 
    1119                 :           6 :     bool in(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
    1120                 :             :             JS::HandleValue) override {
    1121         [ -  + ]:           6 :         if (m_length_direction != GI_DIRECTION_OUT) {
    1122                 :           0 :             gjs_throw(cx,
    1123                 :             :                       "Using different length argument direction for array %s"
    1124                 :             :                       "is not supported for out arrays",
    1125                 :             :                       m_arg_name);
    1126                 :           0 :             return false;
    1127                 :             :         }
    1128                 :           6 :         return set_out_parameter(state, arg);
    1129                 :             :     };
    1130                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
    1131                 :             :                  GIArgument*) override;
    1132                 :             : 
    1133                 :           4 :     Maybe<ReturnTag> return_tag() const override {
    1134                 :           4 :         return Some(ReturnTag{GI_TYPE_TAG_ARRAY});
    1135                 :             :     }
    1136                 :             : };
    1137                 :             : 
    1138                 :             : using ArrayLengthOut = SimpleOut;
    1139                 :             : 
    1140                 :             : struct NotIntrospectable : SkipAll {
    1141                 :          69 :     explicit NotIntrospectable(NotIntrospectableReason reason)
    1142                 :          69 :         : m_reason(reason) {}
    1143                 :             :     NotIntrospectableReason m_reason;
    1144                 :             : 
    1145                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1146                 :             :             JS::HandleValue) override;
    1147                 :             : };
    1148                 :             : 
    1149                 :             : struct NullableIn : SkipAll, Nullable {
    1150                 :       13936 :     inline bool in(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
    1151                 :             :                    JS::HandleValue) override {
    1152                 :       13936 :         return handle_nullable(cx, arg, m_arg_name);
    1153                 :             :     }
    1154                 :             : 
    1155                 :         136 :     GjsArgumentFlags flags() const override {
    1156                 :         136 :         return Argument::flags() | Nullable::flags();
    1157                 :             :     }
    1158                 :             : };
    1159                 :             : 
    1160                 :             : struct Instance : NullableIn {
    1161                 :             :     //  Some calls accept null for the instance (thus we inherit from
    1162                 :             :     //  NullableIn), but generally in an object oriented language it's wrong to
    1163                 :             :     //  call a method on null.
    1164                 :             :     //  As per this we actually default to SkipAll methods.
    1165                 :             : 
    1166                 :           0 :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1167                 :             :             JS::HandleValue) override {
    1168                 :           0 :         return skip();
    1169                 :             :     }
    1170                 :             : 
    1171                 :       40101 :     Maybe<const Instance*> as_instance() const override { return Some(this); }
    1172                 :             : 
    1173                 :             :     //  The instance GType can be useful only in few cases such as GObjects and
    1174                 :             :     //  GInterfaces, so we don't store it by default, unless needed.
    1175                 :             :     //  See Function's code to see where this is relevant.
    1176                 :         247 :     virtual GType gtype() const { return G_TYPE_NONE; }
    1177                 :             : };
    1178                 :             : 
    1179                 :             : struct EnumIn : Instance, Enum {
    1180                 :             :     using Enum::Enum;
    1181                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1182                 :             :             JS::HandleValue) override;
    1183                 :             : };
    1184                 :             : 
    1185                 :             : struct FlagsIn : Instance, Flags {
    1186                 :             :     using Flags::Flags;
    1187                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1188                 :             :             JS::HandleValue) override;
    1189                 :             : };
    1190                 :             : 
    1191                 :             : struct RegisteredIn : Instance, RegisteredType, Transferable {
    1192                 :             :     using RegisteredType::RegisteredType;
    1193                 :             : 
    1194                 :       39854 :     GType gtype() const override { return RegisteredType::gtype(); }
    1195                 :             : };
    1196                 :             : 
    1197                 :             : template <GI::InfoTag TAG>
    1198                 :             : struct RegisteredInterfaceIn : Instance,
    1199                 :             :                                RegisteredInterface<TAG>,
    1200                 :             :                                Transferable {
    1201                 :             :     using RegisteredInterface<TAG>::RegisteredInterface;
    1202                 :             : 
    1203                 :           0 :     GType gtype() const override { return RegisteredInterface<TAG>::gtype(); }
    1204                 :             : };
    1205                 :             : 
    1206                 :             : struct ForeignStructInstanceIn : RegisteredInterfaceIn<GI::InfoTag::STRUCT> {
    1207                 :             :     using RegisteredInterfaceIn<GI::InfoTag::STRUCT>::RegisteredInterfaceIn;
    1208                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1209                 :             :             JS::HandleValue) override;
    1210                 :             : };
    1211                 :             : 
    1212                 :             : struct ForeignStructIn : ForeignStructInstanceIn {
    1213                 :             :     using ForeignStructInstanceIn::ForeignStructInstanceIn;
    1214                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
    1215                 :             :                  GIArgument*) override;
    1216                 :             : };
    1217                 :             : 
    1218                 :             : struct FallbackInterfaceIn
    1219                 :             :     : RegisteredInterfaceIn<GI::InfoTag::REGISTERED_TYPE> {
    1220                 :             :     using RegisteredInterfaceIn::RegisteredInterfaceIn;
    1221                 :             : 
    1222                 :         127 :     bool in(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
    1223                 :             :             JS::HandleValue value) override {
    1224                 :         254 :         return gjs_value_to_interface_gi_argument(
    1225                 :         127 :             cx, value, m_info, m_transfer, arg, m_arg_name,
    1226                 :         254 :             GJS_ARGUMENT_ARGUMENT, flags());
    1227                 :             :     }
    1228                 :             : };
    1229                 :             : 
    1230                 :             : struct GdkAtomIn : NullableIn {
    1231                 :           8 :     bool in(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
    1232                 :             :             JS::HandleValue value) override {
    1233                 :           8 :         return gjs_value_to_gdk_atom_gi_argument(cx, value, arg, m_arg_name,
    1234                 :           8 :                                                  GJS_ARGUMENT_ARGUMENT);
    1235                 :             :     }
    1236                 :             : };
    1237                 :             : 
    1238                 :             : struct BoxedInTransferNone : RegisteredIn {
    1239                 :             :     using RegisteredIn::RegisteredIn;
    1240                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1241                 :             :             JS::HandleValue) override;
    1242                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
    1243                 :             :                  GIArgument*) override;
    1244                 :       53591 :     virtual Maybe<const GI::BaseInfo> info() const { return {}; }
    1245                 :             : };
    1246                 :             : 
    1247                 :             : struct BoxedIn : BoxedInTransferNone {
    1248                 :             :     using BoxedInTransferNone::BoxedInTransferNone;
    1249                 :             :     // This is a smart argument, no release needed
    1250                 :       67205 :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
    1251                 :             :                  GIArgument*) override {
    1252                 :       67205 :         return skip();
    1253                 :             :     }
    1254                 :             : };
    1255                 :             : 
    1256                 :             : struct UnregisteredBoxedIn : BoxedIn,
    1257                 :             :                              HasIntrospectionInfo<GI::InfoTag::STRUCT> {
    1258                 :           8 :     explicit UnregisteredBoxedIn(const GI::StructInfo info)
    1259                 :           8 :         : BoxedIn(info.gtype(), info.type()), HasIntrospectionInfo(info) {}
    1260                 :             :     // This is a smart argument, no release needed
    1261                 :             : };
    1262                 :             : 
    1263                 :             : struct GValueIn : BoxedIn {
    1264                 :             :     using BoxedIn::BoxedIn;
    1265                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1266                 :             :             JS::HandleValue) override;
    1267                 :             : };
    1268                 :             : 
    1269                 :             : struct GValueInTransferNone : GValueIn {
    1270                 :             :     using GValueIn::GValueIn;
    1271                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
    1272                 :             :                  GIArgument*) override;
    1273                 :             : };
    1274                 :             : 
    1275                 :             : struct GClosureInTransferNone : BoxedInTransferNone {
    1276                 :             :     using BoxedInTransferNone::BoxedInTransferNone;
    1277                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1278                 :             :             JS::HandleValue) override;
    1279                 :             : };
    1280                 :             : 
    1281                 :             : struct GClosureIn : GClosureInTransferNone {
    1282                 :             :     using GClosureInTransferNone::GClosureInTransferNone;
    1283                 :           0 :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
    1284                 :             :                  GIArgument*) override {
    1285                 :           0 :         return skip();
    1286                 :             :     }
    1287                 :             : };
    1288                 :             : 
    1289                 :             : struct GBytesIn : BoxedIn {
    1290                 :             :     using BoxedIn::BoxedIn;
    1291                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1292                 :             :             JS::HandleValue) override;
    1293                 :             :     bool release(JSContext* cx, GjsFunctionCallState* state, GIArgument* in_arg,
    1294                 :             :                  GIArgument* out_arg) override;
    1295                 :             : };
    1296                 :             : 
    1297                 :             : struct GBytesInTransferNone : GBytesIn {
    1298                 :             :     using GBytesIn::GBytesIn;
    1299                 :          36 :     bool release(JSContext* cx, GjsFunctionCallState* state, GIArgument* in_arg,
    1300                 :             :                  GIArgument* out_arg) override {
    1301                 :          36 :         return BoxedInTransferNone::release(cx, state, in_arg, out_arg);
    1302                 :             :     }
    1303                 :             : };
    1304                 :             : 
    1305                 :             : struct ObjectIn : RegisteredIn {
    1306                 :             :     using RegisteredIn::RegisteredIn;
    1307                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1308                 :             :             JS::HandleValue) override;
    1309                 :             :     // This is a smart argument, no release needed
    1310                 :             : };
    1311                 :             : 
    1312                 :             : struct InterfaceIn : RegisteredIn {
    1313                 :             :     using RegisteredIn::RegisteredIn;
    1314                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1315                 :             :             JS::HandleValue) override;
    1316                 :             :     // This is a smart argument, no release needed
    1317                 :             : };
    1318                 :             : 
    1319                 :             : struct FundamentalIn : RegisteredIn {
    1320                 :             :     using RegisteredIn::RegisteredIn;
    1321                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1322                 :             :             JS::HandleValue) override;
    1323                 :             :     // This is a smart argument, no release needed
    1324                 :             : };
    1325                 :             : 
    1326                 :             : struct UnionIn : RegisteredIn {
    1327                 :             :     using RegisteredIn::RegisteredIn;
    1328                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1329                 :             :             JS::HandleValue) override;
    1330                 :             :     // This is a smart argument, no release needed
    1331                 :             : };
    1332                 :             : 
    1333                 :             : struct NullIn : NullableIn {
    1334                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1335                 :             :             JS::HandleValue) override;
    1336                 :             : };
    1337                 :             : 
    1338                 :             : struct BooleanIn : SkipAll {
    1339                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1340                 :             :             JS::HandleValue) override;
    1341                 :             : };
    1342                 :             : 
    1343                 :             : template <typename TAG>
    1344                 :             : struct NumericIn : SkipAll {
    1345                 :             :     static_assert(std::is_arithmetic_v<Tag::RealT<TAG>>, "Not arithmetic type");
    1346                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1347                 :             :             JS::HandleValue) override;
    1348                 :             : };
    1349                 :             : 
    1350                 :             : template <typename TAG>
    1351                 :             : struct NumericInOut : NumericIn<TAG>, Positioned {
    1352                 :             :     static_assert(std::is_arithmetic_v<Tag::RealT<TAG>>, "Not arithmetic type");
    1353                 :          36 :     bool in(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
    1354                 :             :             JS::HandleValue value) override {
    1355         [ -  + ]:          36 :         if (!NumericIn<TAG>::in(cx, state, arg, value))
    1356                 :           0 :             return false;
    1357                 :             : 
    1358                 :          36 :         return set_inout_parameter(state, arg);
    1359                 :             :     }
    1360                 :          36 :     bool out(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
    1361                 :             :              JS::MutableHandleValue value) override {
    1362                 :          36 :         return Gjs::c_value_to_js_checked<TAG>(cx, gjs_arg_get<TAG>(arg),
    1363                 :          36 :                                                value);
    1364                 :             :     }
    1365                 :             : };
    1366                 :             : 
    1367                 :             : using BooleanInOut = NumericInOut<Tag::GBoolean>;
    1368                 :             : 
    1369                 :             : struct UnicharIn : SkipAll {
    1370                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1371                 :             :             JS::HandleValue) override;
    1372                 :             : };
    1373                 :             : 
    1374                 :             : struct GTypeIn : SkipAll {
    1375                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1376                 :             :             JS::HandleValue) override;
    1377                 :             : };
    1378                 :             : 
    1379                 :             : template <GITypeTag TAG = GI_TYPE_TAG_UTF8>
    1380                 :             : struct StringInTransferNone : NullableIn {
    1381                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1382                 :             :             JS::HandleValue) override;
    1383                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
    1384                 :             :                  GIArgument*) override;
    1385                 :             : };
    1386                 :             : 
    1387                 :             : struct StringIn : StringInTransferNone<GI_TYPE_TAG_UTF8> {
    1388                 :           1 :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
    1389                 :             :                  GIArgument*) override {
    1390                 :           1 :         return skip();
    1391                 :             :     }
    1392                 :             : };
    1393                 :             : 
    1394                 :             : template <GITransfer TRANSFER = GI_TRANSFER_NOTHING>
    1395                 :             : struct StringOutBase : SkipAll {
    1396                 :         695 :     bool out(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
    1397                 :             :              JS::MutableHandleValue value) override {
    1398                 :         695 :         return Gjs::c_value_to_js(cx, gjs_arg_get<char*>(arg), value);
    1399                 :             :     }
    1400                 :         695 :     bool release(JSContext* cx, GjsFunctionCallState*, GIArgument*,
    1401                 :             :                  GIArgument* out_arg [[maybe_unused]]) override {
    1402                 :             :         if constexpr (TRANSFER == GI_TRANSFER_NOTHING) {
    1403                 :         649 :             return skip();
    1404                 :             :         } else if constexpr (TRANSFER == GI_TRANSFER_EVERYTHING) {
    1405         [ +  + ]:          46 :             g_clear_pointer(&gjs_arg_member<char*>(out_arg), g_free);
    1406                 :          46 :             return true;
    1407                 :             :         } else {
    1408                 :             :             return invalid(cx, G_STRFUNC);
    1409                 :             :         }
    1410                 :             :     }
    1411                 :             : };
    1412                 :             : 
    1413                 :             : template <GITransfer TRANSFER = GI_TRANSFER_NOTHING>
    1414                 :             : struct StringReturn : StringOutBase<TRANSFER> {
    1415                 :           0 :     bool in(JSContext* cx, GjsFunctionCallState*, GIArgument*,
    1416                 :             :             JS::HandleValue) override {
    1417                 :           0 :         return Argument::invalid(cx, G_STRFUNC);
    1418                 :             :     }
    1419                 :             : 
    1420                 :         675 :     Maybe<ReturnTag> return_tag() const override {
    1421                 :         675 :         return Some(ReturnTag{GI_TYPE_TAG_UTF8});
    1422                 :             :     }
    1423                 :             : };
    1424                 :             : 
    1425                 :             : template <GITransfer TRANSFER = GI_TRANSFER_NOTHING>
    1426                 :             : struct StringOut : StringOutBase<TRANSFER>, Positioned {
    1427                 :          20 :     bool in(JSContext*, GjsFunctionCallState* state, GIArgument* arg,
    1428                 :             :             JS::HandleValue) override {
    1429                 :          20 :         return set_out_parameter(state, arg);
    1430                 :             :     }
    1431                 :             : };
    1432                 :             : 
    1433                 :             : using FilenameInTransferNone = StringInTransferNone<GI_TYPE_TAG_FILENAME>;
    1434                 :             : 
    1435                 :             : struct FilenameIn : FilenameInTransferNone {
    1436                 :           0 :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
    1437                 :             :                  GIArgument*) override {
    1438                 :           0 :         return skip();
    1439                 :             :     }
    1440                 :             : };
    1441                 :             : 
    1442                 :             : // .out is ignored for the instance parameter
    1443                 :             : struct GTypeStructInstanceIn : Instance {
    1444                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1445                 :             :             JS::HandleValue) override;
    1446                 :             :     // no out
    1447                 :           0 :     bool out(JSContext* cx, GjsFunctionCallState*, GIArgument*,
    1448                 :             :              JS::MutableHandleValue) override {
    1449                 :           0 :         return invalid(cx, G_STRFUNC);
    1450                 :             :     };
    1451                 :             : };
    1452                 :             : 
    1453                 :             : struct ParamInstanceIn : Instance, Transferable {
    1454                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1455                 :             :             JS::HandleValue) override;
    1456                 :             :     // no out
    1457                 :           0 :     bool out(JSContext* cx, GjsFunctionCallState*, GIArgument*,
    1458                 :             :              JS::MutableHandleValue) override {
    1459                 :           0 :         return invalid(cx, G_STRFUNC);
    1460                 :             :     };
    1461                 :             : };
    1462                 :             : 
    1463                 :             : struct CallbackIn : SkipAll, Callback {
    1464                 :             :     using Callback::Callback;
    1465                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1466                 :             :             JS::HandleValue) override;
    1467                 :             : 
    1468                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
    1469                 :             :                  GIArgument*) override;
    1470                 :             :  private:
    1471                 :             :     ffi_closure *m_ffi_closure;
    1472                 :             : };
    1473                 :             : 
    1474                 :             : struct BasicExplicitCArrayOut : ExplicitArrayBase, BasicCArray, Positioned {
    1475                 :         644 :     explicit BasicExplicitCArrayOut(GITypeTag element_tag, unsigned length_pos,
    1476                 :             :                                     GITypeTag length_tag,
    1477                 :             :                                     GIDirection length_direction)
    1478                 :         644 :         : ExplicitArrayBase(length_pos, length_tag, length_direction),
    1479                 :         644 :           BasicCArray(element_tag) {}
    1480                 :             : 
    1481                 :          16 :     bool in(JSContext*, GjsFunctionCallState* state, GIArgument* arg,
    1482                 :             :             JS::HandleValue) override {
    1483                 :          16 :         return set_out_parameter(state, arg);
    1484                 :             :     };
    1485                 :          29 :     bool out(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
    1486                 :             :              JS::MutableHandleValue value) override {
    1487                 :          29 :         GIArgument* length_arg = &(state->out_cvalue(m_length_pos));
    1488                 :          29 :         size_t length = gjs_gi_argument_get_array_length(m_tag, length_arg);
    1489                 :             : 
    1490                 :          29 :         return gjs_value_from_basic_explicit_array(cx, value, m_element_tag,
    1491                 :          29 :                                                    arg, length);
    1492                 :             :     }
    1493                 :          29 :     bool release(JSContext*, GjsFunctionCallState* state,
    1494                 :             :                  [[maybe_unused]] GIArgument* in_arg,
    1495                 :             :                  GIArgument* out_arg) override {
    1496                 :          29 :         GIArgument* length_arg = &state->out_cvalue(m_length_pos);
    1497                 :          29 :         size_t length = gjs_gi_argument_get_array_length(m_tag, length_arg);
    1498                 :             : 
    1499                 :          29 :         gjs_gi_argument_release_basic_out_array(m_transfer, m_element_tag,
    1500                 :             :                                                 length, out_arg);
    1501                 :          29 :         return true;
    1502                 :             :     }
    1503                 :             : 
    1504                 :          13 :     Maybe<ReturnTag> return_tag() const override {
    1505                 :          13 :         return Some(ReturnTag{GI_TYPE_TAG_ARRAY});
    1506                 :             :     }
    1507                 :             : };
    1508                 :             : 
    1509                 :             : struct BasicExplicitCArrayIn : BasicExplicitCArrayOut {
    1510                 :             :     using BasicExplicitCArrayOut::BasicExplicitCArrayOut;
    1511                 :             : 
    1512                 :         118 :     bool in(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
    1513                 :             :             JS::HandleValue value) override {
    1514                 :             :         void* data;
    1515                 :             :         size_t length;
    1516                 :             : 
    1517         [ +  + ]:         118 :         if (!gjs_array_to_basic_explicit_array(
    1518                 :             :                 cx, value, m_element_tag, m_arg_name, GJS_ARGUMENT_ARGUMENT,
    1519                 :         118 :                 flags(), &data, &length))
    1520                 :           4 :             return false;
    1521                 :             : 
    1522                 :         114 :         gjs_gi_argument_set_array_length(m_tag, &state->in_cvalue(m_length_pos),
    1523                 :             :                                          length);
    1524                 :         114 :         gjs_arg_set(arg, data);
    1525                 :         114 :         return true;
    1526                 :             :     }
    1527                 :          93 :     bool out(JSContext*, GjsFunctionCallState*, GIArgument*,
    1528                 :             :              JS::MutableHandleValue) override {
    1529                 :          93 :         return skip();
    1530                 :             :     }
    1531                 :          94 :     bool release(JSContext*, GjsFunctionCallState* state, GIArgument* in_arg,
    1532                 :             :                  [[maybe_unused]] GIArgument* out_arg) override {
    1533                 :          94 :         GIArgument* length_arg = &state->in_cvalue(m_length_pos);
    1534                 :          94 :         size_t length = gjs_gi_argument_get_array_length(m_tag, length_arg);
    1535                 :             : 
    1536                 :             :         GITransfer transfer =
    1537         [ +  + ]:          94 :             state->call_completed() ? m_transfer : GI_TRANSFER_NOTHING;
    1538                 :             : 
    1539                 :          94 :         gjs_gi_argument_release_basic_in_array(transfer, m_element_tag, length,
    1540                 :             :                                                in_arg);
    1541                 :          94 :         return true;
    1542                 :             :     }
    1543                 :             : };
    1544                 :             : 
    1545                 :             : struct BasicExplicitCArrayInOut : BasicExplicitCArrayIn {
    1546                 :             :     using BasicExplicitCArrayIn::BasicExplicitCArrayIn;
    1547                 :             : 
    1548                 :          20 :     bool in(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
    1549                 :             :             JS::HandleValue value) override {
    1550         [ -  + ]:          20 :         if (!BasicExplicitCArrayIn::in(cx, state, arg, value))
    1551                 :           0 :             return false;
    1552                 :             : 
    1553         [ +  + ]:          20 :         if (!gjs_arg_get<void*>(arg)) {
    1554                 :             :             // Special case where we were given JS null to also pass null for
    1555                 :             :             // length, and not a pointer to an integer that derefs to 0.
    1556                 :           9 :             gjs_arg_unset(&state->in_cvalue(m_length_pos));
    1557                 :           9 :             gjs_arg_unset(&state->out_cvalue(m_length_pos));
    1558                 :           9 :             gjs_arg_unset(&state->inout_original_cvalue(m_length_pos));
    1559                 :             : 
    1560                 :           9 :             gjs_arg_unset(&state->out_cvalue(m_arg_pos));
    1561                 :           9 :             gjs_arg_unset(&state->inout_original_cvalue(m_arg_pos));
    1562                 :             : 
    1563                 :           9 :             return true;
    1564                 :             :         }
    1565                 :             : 
    1566                 :          11 :         state->out_cvalue(m_length_pos) =
    1567                 :          11 :             state->inout_original_cvalue(m_length_pos) =
    1568                 :          11 :                 state->in_cvalue(m_length_pos);
    1569                 :          11 :         gjs_arg_set(&state->in_cvalue(m_length_pos),
    1570                 :          11 :                     &state->out_cvalue(m_length_pos));
    1571                 :          11 :         return set_inout_parameter(state, arg);
    1572                 :             :     }
    1573                 :          20 :     bool out(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
    1574                 :             :              JS::MutableHandleValue value) override {
    1575                 :          20 :         GIArgument* length_arg = &(state->out_cvalue(m_length_pos));
    1576                 :          20 :         size_t length = gjs_gi_argument_get_array_length(m_tag, length_arg);
    1577                 :             : 
    1578                 :          20 :         return gjs_value_from_basic_explicit_array(cx, value, m_element_tag,
    1579                 :          20 :                                                    arg, length);
    1580                 :             :     }
    1581                 :          20 :     bool release(JSContext*, GjsFunctionCallState* state,
    1582                 :             :                  GIArgument* in_arg [[maybe_unused]],
    1583                 :             :                  GIArgument* out_arg) override {
    1584                 :          20 :         GIArgument* length_arg = &state->out_cvalue(m_length_pos);
    1585                 :          20 :         size_t length = gjs_gi_argument_get_array_length(m_tag, length_arg);
    1586                 :             : 
    1587                 :          20 :         GIArgument* original_out_arg = &state->inout_original_cvalue(m_arg_pos);
    1588         [ +  + ]:          40 :         if (gjs_arg_get<void*>(original_out_arg) !=
    1589                 :          20 :             gjs_arg_get<void*>(out_arg)) {
    1590                 :             :             GITransfer transfer =
    1591         [ +  - ]:           6 :                 state->call_completed() ? m_transfer : GI_TRANSFER_NOTHING;
    1592                 :           6 :             gjs_gi_argument_release_basic_in_array(transfer, m_element_tag,
    1593                 :             :                                                    length, original_out_arg);
    1594                 :             :         }
    1595                 :             : 
    1596                 :          20 :         gjs_gi_argument_release_basic_out_array(m_transfer, m_element_tag,
    1597                 :             :                                                 length, out_arg);
    1598                 :          20 :         return true;
    1599                 :             :     }
    1600                 :             : };
    1601                 :             : 
    1602                 :             : struct CallerAllocatesOut : FallbackOut, CallerAllocates {
    1603                 :          16 :     CallerAllocatesOut(const GI::TypeInfo type_info, size_t size)
    1604                 :          16 :         : FallbackOut(type_info), CallerAllocates(size) {}
    1605                 :             :     bool in(JSContext*, GjsFunctionCallState*, GIArgument*,
    1606                 :             :             JS::HandleValue) override;
    1607                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
    1608                 :             :                  GIArgument*) override;
    1609                 :             : 
    1610                 :           0 :     GjsArgumentFlags flags() const override {
    1611                 :           0 :         return FallbackOut::flags() | GjsArgumentFlags::CALLER_ALLOCATES;
    1612                 :             :     }
    1613                 :             : };
    1614                 :             : 
    1615                 :             : struct BoxedCallerAllocatesOut : CallerAllocatesOut, GTypedType {
    1616                 :          10 :     BoxedCallerAllocatesOut(const GI::TypeInfo type_info, size_t size,
    1617                 :             :                             GType gtype)
    1618                 :          10 :         : CallerAllocatesOut(type_info, size), GTypedType(gtype) {}
    1619                 :             :     bool release(JSContext*, GjsFunctionCallState*, GIArgument*,
    1620                 :             :                  GIArgument*) override;
    1621                 :             : };
    1622                 :             : 
    1623                 :             : struct ZeroTerminatedArrayInOut : FallbackInOut {
    1624                 :             :     using FallbackInOut::FallbackInOut;
    1625                 :           2 :     bool release(JSContext* cx, GjsFunctionCallState* state, GIArgument*,
    1626                 :             :                  GIArgument* out_arg) override {
    1627                 :             :         GITransfer transfer =
    1628         [ +  - ]:           2 :             state->call_completed() ? m_transfer : GI_TRANSFER_NOTHING;
    1629                 :           2 :         GIArgument* original_out_arg = &state->inout_original_cvalue(m_arg_pos);
    1630         [ -  + ]:           2 :         if (!gjs_gi_argument_release_in_array(cx, transfer, m_type_info,
    1631                 :             :                                               original_out_arg))
    1632                 :           0 :             return false;
    1633                 :             : 
    1634                 :           2 :         transfer =
    1635         [ +  - ]:           2 :             state->call_completed() ? m_transfer : GI_TRANSFER_EVERYTHING;
    1636                 :           4 :         return gjs_gi_argument_release_out_array(cx, transfer, m_type_info,
    1637                 :           2 :                                                  out_arg);
    1638                 :             :     }
    1639                 :             : };
    1640                 :             : 
    1641                 :             : struct ZeroTerminatedArrayIn : FallbackIn {
    1642                 :             :     using FallbackIn::FallbackIn;
    1643                 :           5 :     bool out(JSContext*, GjsFunctionCallState*, GIArgument*,
    1644                 :             :              JS::MutableHandleValue) override {
    1645                 :           5 :         return skip();
    1646                 :             :     }
    1647                 :             : 
    1648                 :           5 :     bool release(JSContext* cx, GjsFunctionCallState* state, GIArgument* in_arg,
    1649                 :             :                  GIArgument*) override {
    1650                 :             :         GITransfer transfer =
    1651         [ +  - ]:           5 :             state->call_completed() ? m_transfer : GI_TRANSFER_NOTHING;
    1652                 :             : 
    1653                 :          10 :         return gjs_gi_argument_release_in_array(cx, transfer, m_type_info,
    1654                 :           5 :                                                 in_arg);
    1655                 :             :     }
    1656                 :             : 
    1657                 :           5 :     GjsArgumentFlags flags() const override {
    1658                 :           5 :         return Argument::flags() | Nullable::flags();
    1659                 :             :     }
    1660                 :             : };
    1661                 :             : 
    1662                 :             : struct FixedSizeArrayIn : FallbackIn {
    1663                 :             :     using FallbackIn::FallbackIn;
    1664                 :           2 :     bool out(JSContext*, GjsFunctionCallState*, GIArgument*,
    1665                 :             :              JS::MutableHandleValue) override {
    1666                 :           2 :         return skip();
    1667                 :             :     }
    1668                 :             : 
    1669                 :           2 :     bool release(JSContext* cx, GjsFunctionCallState* state, GIArgument* in_arg,
    1670                 :             :                  GIArgument*) override {
    1671                 :             :         GITransfer transfer =
    1672         [ +  - ]:           2 :             state->call_completed() ? m_transfer : GI_TRANSFER_NOTHING;
    1673                 :             : 
    1674                 :           2 :         size_t size = m_type_info.array_fixed_size().value();
    1675                 :           4 :         return gjs_gi_argument_release_in_array(cx, transfer, m_type_info, size,
    1676                 :           2 :                                                 in_arg);
    1677                 :             :     }
    1678                 :             : };
    1679                 :             : 
    1680                 :             : struct FixedSizeArrayInOut : FallbackInOut {
    1681                 :             :     using FallbackInOut::FallbackInOut;
    1682                 :           2 :     bool release(JSContext* cx, GjsFunctionCallState* state, GIArgument*,
    1683                 :             :                  GIArgument* out_arg) override {
    1684                 :             :         GITransfer transfer =
    1685         [ +  - ]:           2 :             state->call_completed() ? m_transfer : GI_TRANSFER_NOTHING;
    1686                 :           2 :         GIArgument* original_out_arg = &state->inout_original_cvalue(m_arg_pos);
    1687                 :           2 :         size_t size = m_type_info.array_fixed_size().value();
    1688         [ -  + ]:           2 :         if (!gjs_gi_argument_release_in_array(cx, transfer, m_type_info, size,
    1689                 :             :                                               original_out_arg))
    1690                 :           0 :             return false;
    1691                 :             : 
    1692                 :           2 :         transfer =
    1693         [ +  - ]:           2 :             state->call_completed() ? m_transfer : GI_TRANSFER_EVERYTHING;
    1694                 :           4 :         return gjs_gi_argument_release_out_array(cx, transfer, m_type_info,
    1695                 :           2 :                                                  size, out_arg);
    1696                 :             :     }
    1697                 :             : };
    1698                 :             : 
    1699                 :             : GJS_JSAPI_RETURN_CONVENTION
    1700                 :           3 : bool NotIntrospectable::in(JSContext* cx, GjsFunctionCallState* state,
    1701                 :             :                            GIArgument*, JS::HandleValue) {
    1702                 :           3 :     const char* reason_string = "invalid introspection";
    1703                 :             : 
    1704   [ -  +  +  -  :           3 :     switch (m_reason) {
          +  -  -  -  -  
                      - ]
    1705                 :           0 :         case CALLBACK_OUT:
    1706                 :           0 :             reason_string = "callback out-argument";
    1707                 :           0 :             break;
    1708                 :           1 :         case DESTROY_NOTIFY_NO_CALLBACK:
    1709                 :           1 :             reason_string = "DestroyNotify argument with no callback";
    1710                 :           1 :             break;
    1711                 :           1 :         case DESTROY_NOTIFY_NO_USER_DATA:
    1712                 :           1 :             reason_string = "DestroyNotify argument with no user data";
    1713                 :           1 :             break;
    1714                 :           0 :         case INTERFACE_TRANSFER_CONTAINER:
    1715                 :           0 :             reason_string = "type not supported for (transfer container)";
    1716                 :           0 :             break;
    1717                 :           1 :         case OUT_CALLER_ALLOCATES_NON_STRUCT:
    1718                 :           1 :             reason_string = "type not supported for (out caller-allocates)";
    1719                 :           1 :             break;
    1720                 :           0 :         case UNREGISTERED_BOXED_WITH_TRANSFER:
    1721                 :           0 :             reason_string =
    1722                 :             :                 "boxed type with transfer not registered as a GType";
    1723                 :           0 :             break;
    1724                 :           0 :         case UNREGISTERED_UNION:
    1725                 :           0 :             reason_string = "union type not registered as a GType";
    1726                 :           0 :             break;
    1727                 :           0 :         case UNSUPPORTED_TYPE:
    1728                 :           0 :             reason_string = "type not supported by introspection";
    1729                 :           0 :             break;
    1730                 :           0 :         case LAST_REASON:
    1731                 :             :             g_assert_not_reached();
    1732                 :             :     }
    1733                 :             : 
    1734                 :           3 :     gjs_throw(cx,
    1735                 :             :               "Function %s() cannot be called: argument '%s' is not "
    1736                 :             :               "introspectable because it has a %s",
    1737                 :           6 :               state->display_name().get(), m_arg_name, reason_string);
    1738                 :           3 :     return false;
    1739                 :             : }
    1740                 :             : 
    1741                 :             : GJS_JSAPI_RETURN_CONVENTION
    1742                 :          10 : bool FallbackIn::in(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
    1743                 :             :                     JS::HandleValue value) {
    1744                 :          20 :     return gjs_value_to_gi_argument(cx, value, m_type_info, m_arg_name,
    1745                 :          10 :                                     GJS_ARGUMENT_ARGUMENT, m_transfer, flags(),
    1746                 :          10 :                                     arg);
    1747                 :             : }
    1748                 :             : 
    1749                 :             : GJS_JSAPI_RETURN_CONVENTION
    1750                 :          11 : bool FallbackInOut::in(JSContext* cx, GjsFunctionCallState* state,
    1751                 :             :                        GIArgument* arg, JS::HandleValue value) {
    1752                 :          11 :     return gjs_value_to_gi_argument(cx, value, m_type_info, m_arg_name,
    1753                 :          11 :                                     GJS_ARGUMENT_ARGUMENT, m_transfer, flags(),
    1754   [ +  -  +  - ]:          22 :                                     arg) &&
    1755                 :          22 :            set_inout_parameter(state, arg);
    1756                 :             : }
    1757                 :             : 
    1758                 :             : GJS_JSAPI_RETURN_CONVENTION
    1759                 :         245 : bool CArrayIn::in(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
    1760                 :             :                   JS::HandleValue value) {
    1761                 :             :     void* data;
    1762                 :             :     size_t length;
    1763                 :             : 
    1764         [ -  + ]:         245 :     if (m_length_direction != GI_DIRECTION_IN) {
    1765                 :           0 :         gjs_throw(cx,
    1766                 :             :                   "Using different length argument direction for array %s is "
    1767                 :             :                   "not supported for in arrays",
    1768                 :             :                   m_arg_name);
    1769                 :           0 :         return false;
    1770                 :             :     }
    1771                 :             : 
    1772         [ +  + ]:         245 :     if (!gjs_array_to_explicit_array(cx, value, m_type_info, m_arg_name,
    1773                 :         245 :                                      GJS_ARGUMENT_ARGUMENT, m_transfer, flags(),
    1774                 :             :                                      &data, &length))
    1775                 :           1 :         return false;
    1776                 :             : 
    1777                 :         244 :     gjs_gi_argument_set_array_length(m_tag, &state->in_cvalue(m_length_pos),
    1778                 :             :                                      length);
    1779                 :         244 :     gjs_arg_set(arg, data);
    1780                 :         244 :     return true;
    1781                 :             : }
    1782                 :             : 
    1783                 :             : GJS_JSAPI_RETURN_CONVENTION
    1784                 :           2 : bool CArrayInOut::in(JSContext* cx, GjsFunctionCallState* state,
    1785                 :             :                      GIArgument* arg, JS::HandleValue value) {
    1786         [ -  + ]:           2 :     if (m_length_direction != GI_DIRECTION_INOUT) {
    1787                 :           0 :         gjs_throw(cx,
    1788                 :             :                   "Using different length argument direction for array %s is "
    1789                 :             :                   "not supported for inout arrays",
    1790                 :             :                   m_arg_name);
    1791                 :           0 :         return false;
    1792                 :             :     }
    1793                 :             : 
    1794                 :             :     void* data;
    1795                 :             :     size_t length;
    1796         [ -  + ]:           2 :     if (!gjs_array_to_explicit_array(cx, value, m_type_info, m_arg_name,
    1797                 :           2 :                                      GJS_ARGUMENT_ARGUMENT, m_transfer, flags(),
    1798                 :             :                                      &data, &length))
    1799                 :           0 :         return false;
    1800                 :             : 
    1801                 :           2 :     gjs_gi_argument_set_array_length(m_tag, &state->in_cvalue(m_length_pos),
    1802                 :             :                                      length);
    1803                 :           2 :     gjs_arg_set(arg, data);
    1804                 :             : 
    1805                 :           2 :     uint8_t length_pos = m_length_pos;
    1806                 :           2 :     uint8_t ix = m_arg_pos;
    1807                 :             : 
    1808         [ -  + ]:           2 :     if (!gjs_arg_get<void*>(arg)) {
    1809                 :             :         // Special case where we were given JS null to also pass null for
    1810                 :             :         // length, and not a pointer to an integer that derefs to 0.
    1811                 :           0 :         gjs_arg_unset(&state->in_cvalue(length_pos));
    1812                 :           0 :         gjs_arg_unset(&state->out_cvalue(length_pos));
    1813                 :           0 :         gjs_arg_unset(&state->inout_original_cvalue(length_pos));
    1814                 :             : 
    1815                 :           0 :         gjs_arg_unset(&state->out_cvalue(ix));
    1816                 :           0 :         gjs_arg_unset(&state->inout_original_cvalue(ix));
    1817                 :             :     } else {
    1818                 :           2 :         state->out_cvalue(length_pos) =
    1819                 :           2 :             state->inout_original_cvalue(length_pos) =
    1820                 :           2 :                 state->in_cvalue(length_pos);
    1821                 :           2 :         gjs_arg_set(&state->in_cvalue(length_pos),
    1822                 :           2 :                     &state->out_cvalue(length_pos));
    1823                 :             : 
    1824                 :           2 :         state->out_cvalue(ix) = state->inout_original_cvalue(ix) = *arg;
    1825                 :           2 :         gjs_arg_set(arg, &state->out_cvalue(ix));
    1826                 :             :     }
    1827                 :             : 
    1828                 :           2 :     return true;
    1829                 :             : }
    1830                 :             : 
    1831                 :             : GJS_JSAPI_RETURN_CONVENTION
    1832                 :         262 : bool CallbackIn::in(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
    1833                 :             :                     JS::HandleValue value) {
    1834                 :             :     GjsCallbackTrampoline* trampoline;
    1835                 :             :     void* closure;
    1836                 :             : 
    1837   [ +  +  +  +  :         262 :     if (value.isNull() && m_nullable) {
                   +  + ]
    1838                 :          10 :         closure = nullptr;
    1839                 :          10 :         trampoline = nullptr;
    1840                 :          10 :         m_ffi_closure = nullptr;
    1841                 :             :     } else {
    1842         [ +  + ]:         252 :         if (JS_TypeOfValue(cx, value) != JSTYPE_FUNCTION) {
    1843                 :           2 :             gjs_throw(cx, "Expected function for callback argument %s, got %s",
    1844                 :             :                       m_arg_name, JS::InformalValueTypeName(value));
    1845                 :           2 :             return false;
    1846                 :             :         }
    1847                 :             : 
    1848                 :         250 :         JS::RootedObject callable(cx, &value.toObject());
    1849                 :         250 :         bool is_object_method = !!state->instance_object;
    1850                 :         250 :         trampoline = GjsCallbackTrampoline::create(
    1851                 :         250 :             cx, callable, m_info, m_scope, is_object_method, false);
    1852         [ -  + ]:         250 :         if (!trampoline)
    1853                 :           0 :             return false;
    1854   [ +  +  +  + ]:         250 :         if (m_scope == GI_SCOPE_TYPE_NOTIFIED && is_object_method) {
    1855                 :           2 :             auto* priv = ObjectInstance::for_js(cx, state->instance_object);
    1856         [ -  + ]:           2 :             if (!priv) {
    1857                 :           0 :                 gjs_throw(cx, "Signal connected to wrong type of object");
    1858                 :           0 :                 return false;
    1859                 :             :             }
    1860                 :             : 
    1861         [ -  + ]:           2 :             if (!priv->associate_closure(cx, trampoline))
    1862                 :           0 :                 return false;
    1863                 :             :         }
    1864                 :         250 :         closure = trampoline->closure();
    1865                 :         250 :         m_ffi_closure = trampoline->get_ffi_closure();
    1866         [ +  - ]:         250 :     }
    1867                 :             : 
    1868         [ +  + ]:         260 :     if (has_callback_destroy()) {
    1869                 :         102 :         GDestroyNotify destroy_notify = nullptr;
    1870         [ +  + ]:         102 :         if (trampoline) {
    1871                 :             :             /* Adding another reference and a DestroyNotify that unsets it */
    1872                 :          98 :             g_closure_ref(trampoline);
    1873                 :          98 :             destroy_notify = [](void* data) {
    1874                 :          86 :                 g_assert(data);
    1875                 :          86 :                 g_closure_unref(static_cast<GClosure*>(data));
    1876                 :          86 :             };
    1877                 :             :         }
    1878                 :         102 :         gjs_arg_set(&state->in_cvalue(m_destroy_pos), destroy_notify);
    1879                 :             :     }
    1880         [ +  + ]:         260 :     if (has_callback_closure())
    1881                 :         234 :         gjs_arg_set(&state->in_cvalue(m_closure_pos), trampoline);
    1882                 :             : 
    1883   [ +  +  +  + ]:         260 :     if (trampoline && m_scope == GI_SCOPE_TYPE_ASYNC) {
    1884                 :             :         // Add an extra reference that will be cleared when garbage collecting
    1885                 :             :         // async calls
    1886                 :         118 :         g_closure_ref(trampoline);
    1887                 :             :     }
    1888                 :             : 
    1889                 :             :     bool keep_forever =
    1890         [ +  + ]:         418 :         !has_callback_destroy() &&
    1891   [ +  -  +  + ]:         158 :         (m_scope == GI_SCOPE_TYPE_FOREVER || m_scope == GI_SCOPE_TYPE_NOTIFIED);
    1892                 :             : 
    1893   [ +  +  +  + ]:         260 :     if (trampoline && keep_forever) {
    1894                 :           1 :         trampoline->mark_forever();
    1895                 :             :     }
    1896                 :         260 :     gjs_arg_set(arg, closure);
    1897                 :             : 
    1898                 :         260 :     return true;
    1899                 :             : }
    1900                 :             : 
    1901                 :             : GJS_JSAPI_RETURN_CONVENTION
    1902                 :         120 : bool FallbackOut::in(JSContext*, GjsFunctionCallState* state, GIArgument* arg,
    1903                 :             :                      JS::HandleValue) {
    1904                 :             :     // Default value in case a broken C function doesn't fill in the pointer
    1905                 :         120 :     return set_out_parameter(state, arg);
    1906                 :             : }
    1907                 :             : 
    1908                 :             : GJS_JSAPI_RETURN_CONVENTION
    1909                 :          10 : bool CallerAllocatesOut::in(JSContext*, GjsFunctionCallState* state,
    1910                 :             :                             GIArgument* arg, JS::HandleValue) {
    1911                 :          10 :     void* blob = g_malloc0(m_allocates_size);
    1912                 :          10 :     gjs_arg_set(arg, blob);
    1913                 :          10 :     gjs_arg_set(&state->out_cvalue(m_arg_pos), blob);
    1914                 :          10 :     return true;
    1915                 :             : }
    1916                 :             : 
    1917                 :             : GJS_JSAPI_RETURN_CONVENTION
    1918                 :          18 : bool NullIn::in(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
    1919                 :             :                 JS::HandleValue) {
    1920                 :          18 :     return handle_nullable(cx, arg, m_arg_name);
    1921                 :             : }
    1922                 :             : 
    1923                 :             : GJS_JSAPI_RETURN_CONVENTION
    1924                 :         238 : bool BooleanIn::in(JSContext*, GjsFunctionCallState*, GIArgument* arg,
    1925                 :             :                    JS::HandleValue value) {
    1926                 :         238 :     gjs_arg_set(arg, JS::ToBoolean(value));
    1927                 :         238 :     return true;
    1928                 :             : }
    1929                 :             : 
    1930                 :             : template <typename TAG>
    1931                 :       29536 : GJS_JSAPI_RETURN_CONVENTION bool NumericIn<TAG>::in(JSContext* cx,
    1932                 :             :                                                     GjsFunctionCallState*,
    1933                 :             :                                                     GIArgument* arg,
    1934                 :             :                                                     JS::HandleValue value) {
    1935                 :       29536 :     bool out_of_range = false;
    1936                 :             : 
    1937         [ +  + ]:       29536 :     if (!gjs_arg_set_from_js_value<TAG>(cx, value, arg, &out_of_range)) {
    1938         [ +  + ]:          33 :         if (out_of_range) {
    1939                 :           8 :             gjs_throw(cx, "Argument %s: value is out of range for %s",
    1940                 :             :                       arg_name(), Gjs::static_type_name<TAG>());
    1941                 :             :         }
    1942                 :             : 
    1943                 :          33 :         return false;
    1944                 :             :     }
    1945                 :             : 
    1946                 :             :     gjs_debug_marshal(GJS_DEBUG_GFUNCTION, "%s set to value %s (type %s)",
    1947                 :             :                       Gjs::AutoChar{gjs_argument_display_name(
    1948                 :             :                                         arg_name(), GJS_ARGUMENT_ARGUMENT)}
    1949                 :             :                           .get(),
    1950                 :             :                       std::to_string(gjs_arg_get<TAG>(arg)).c_str(),
    1951                 :             :                       Gjs::static_type_name<TAG>());
    1952                 :             : 
    1953                 :       29503 :     return true;
    1954                 :             : }
    1955                 :             : 
    1956                 :             : GJS_JSAPI_RETURN_CONVENTION
    1957                 :           3 : bool UnicharIn::in(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
    1958                 :             :                    JS::HandleValue value) {
    1959         [ -  + ]:           3 :     if (!value.isString())
    1960                 :           0 :         return report_typeof_mismatch(cx, m_arg_name, value,
    1961                 :           0 :                                       ExpectedType::STRING);
    1962                 :             : 
    1963                 :           3 :     return gjs_unichar_from_string(cx, value, &gjs_arg_member<char32_t>(arg));
    1964                 :             : }
    1965                 :             : 
    1966                 :             : GJS_JSAPI_RETURN_CONVENTION
    1967                 :         750 : bool GTypeIn::in(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
    1968                 :             :                  JS::HandleValue value) {
    1969         [ -  + ]:         750 :     if (value.isNull())
    1970                 :           0 :         return report_invalid_null(cx, m_arg_name);
    1971         [ -  + ]:         750 :     if (!value.isObject())
    1972                 :           0 :         return report_typeof_mismatch(cx, m_arg_name, value,
    1973                 :           0 :                                       ExpectedType::OBJECT);
    1974                 :             : 
    1975                 :         750 :     JS::RootedObject gtype_obj(cx, &value.toObject());
    1976                 :         750 :     return gjs_gtype_get_actual_gtype(cx, gtype_obj,
    1977                 :        1500 :                                       &gjs_arg_member<Tag::GType>(arg));
    1978                 :         750 : }
    1979                 :             : 
    1980                 :             : // Common code for most types that are pointers on the C side
    1981                 :       13954 : bool Nullable::handle_nullable(JSContext* cx, GIArgument* arg,
    1982                 :             :                                const char* arg_name) {
    1983         [ +  + ]:       13954 :     if (!m_nullable)
    1984                 :           3 :         return report_invalid_null(cx, arg_name);
    1985                 :       13951 :     gjs_arg_unset(arg);
    1986                 :       13951 :     return true;
    1987                 :             : }
    1988                 :             : 
    1989                 :             : template <GITypeTag TAG>
    1990                 :        5042 : GJS_JSAPI_RETURN_CONVENTION bool StringInTransferNone<TAG>::in(
    1991                 :             :     JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
    1992                 :             :     JS::HandleValue value) {
    1993         [ +  + ]:        5042 :     if (value.isNull())
    1994                 :          33 :         return NullableIn::in(cx, state, arg, value);
    1995                 :             : 
    1996         [ +  + ]:        5009 :     if (!value.isString())
    1997                 :           2 :         return report_typeof_mismatch(cx, m_arg_name, value,
    1998                 :           2 :                                       ExpectedType::STRING);
    1999                 :             : 
    2000                 :             :     if constexpr (TAG == GI_TYPE_TAG_FILENAME) {
    2001                 :         175 :         AutoChar str;
    2002         [ -  + ]:         175 :         if (!gjs_string_to_filename(cx, value, &str))
    2003                 :           0 :             return false;
    2004                 :         175 :         gjs_arg_set(arg, str.release());
    2005                 :         175 :         return true;
    2006                 :         175 :     } else if constexpr (TAG == GI_TYPE_TAG_UTF8) {
    2007                 :        4832 :         JS::UniqueChars str = gjs_string_to_utf8(cx, value);
    2008         [ -  + ]:        4832 :         if (!str)
    2009                 :           0 :             return false;
    2010                 :        4832 :         gjs_arg_set(arg, js_chars_to_glib(std::move(str)).release());
    2011                 :        4832 :         return true;
    2012                 :        4832 :     } else {
    2013                 :             :         return invalid(cx, G_STRFUNC);
    2014                 :             :     }
    2015                 :             : }
    2016                 :             : 
    2017                 :             : GJS_JSAPI_RETURN_CONVENTION
    2018                 :          33 : bool EnumIn::in(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
    2019                 :             :                 JS::HandleValue value) {
    2020                 :             :     int64_t number;
    2021         [ -  + ]:          33 :     if (!Gjs::js_value_to_c<int64_t>(cx, value, &number))
    2022                 :           0 :         return false;
    2023                 :             : 
    2024                 :             :     // Unpack the values from their uint32_t bitfield. See note in
    2025                 :             :     // Enum::Enum().
    2026                 :             :     int64_t min, max;
    2027         [ +  + ]:          33 :     if (m_unsigned) {
    2028                 :           2 :         min = m_min;
    2029                 :           2 :         max = m_max;
    2030                 :             :     } else {
    2031                 :          31 :         min = static_cast<int32_t>(m_min);
    2032                 :          31 :         max = static_cast<int32_t>(m_max);
    2033                 :             :     }
    2034                 :             : 
    2035   [ +  -  -  + ]:          33 :     if (number > max || number < min) {
    2036                 :           0 :         gjs_throw(cx, "%" PRId64 " is not a valid value for enum argument %s",
    2037                 :             :                   number, m_arg_name);
    2038                 :           0 :         return false;
    2039                 :             :     }
    2040                 :             : 
    2041         [ +  + ]:          33 :     if (m_unsigned)
    2042                 :           2 :         gjs_arg_set<Tag::UnsignedEnum>(arg, number);
    2043                 :             :     else
    2044                 :          31 :         gjs_arg_set<Tag::Enum>(arg, number);
    2045                 :             : 
    2046                 :          33 :     return true;
    2047                 :             : }
    2048                 :             : 
    2049                 :             : GJS_JSAPI_RETURN_CONVENTION
    2050                 :         519 : bool FlagsIn::in(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
    2051                 :             :                  JS::HandleValue value) {
    2052                 :             :     int64_t number;
    2053         [ -  + ]:         519 :     if (!Gjs::js_value_to_c<int64_t>(cx, value, &number))
    2054                 :           0 :         return false;
    2055                 :             : 
    2056         [ -  + ]:         519 :     if ((uint64_t(number) & m_mask) != uint64_t(number)) {
    2057                 :           0 :         gjs_throw(cx,
    2058                 :             :                   "0x%" PRId64 " is not a valid value for flags argument %s",
    2059                 :             :                   number, m_arg_name);
    2060                 :           0 :         return false;
    2061                 :             :     }
    2062                 :             : 
    2063                 :             :     // We cast to unsigned because that's what makes sense, but then we
    2064                 :             :     // put it in the v_int slot because that's what we use to unmarshal
    2065                 :             :     // flags types at the moment.
    2066                 :         519 :     gjs_arg_set<Tag::Enum>(arg, static_cast<unsigned>(number));
    2067                 :         519 :     return true;
    2068                 :             : }
    2069                 :             : 
    2070                 :             : GJS_JSAPI_RETURN_CONVENTION
    2071                 :           9 : bool ForeignStructInstanceIn::in(JSContext* cx, GjsFunctionCallState*,
    2072                 :             :                                  GIArgument* arg, JS::HandleValue value) {
    2073                 :          18 :     return gjs_struct_foreign_convert_to_gi_argument(
    2074                 :           9 :         cx, value, m_info, m_arg_name, GJS_ARGUMENT_ARGUMENT, m_transfer,
    2075                 :          18 :         flags(), arg);
    2076                 :             : }
    2077                 :             : 
    2078                 :             : GJS_JSAPI_RETURN_CONVENTION
    2079                 :         208 : bool GValueIn::in(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
    2080                 :             :                   JS::HandleValue value) {
    2081         [ +  + ]:         208 :     if (value.isObject()) {
    2082                 :         179 :         JS::RootedObject obj(cx, &value.toObject());
    2083                 :             :         GType gtype;
    2084                 :             : 
    2085         [ -  + ]:         179 :         if (!gjs_gtype_get_actual_gtype(cx, obj, &gtype))
    2086                 :           0 :             return false;
    2087                 :             : 
    2088         [ +  + ]:         179 :         if (gtype == G_TYPE_VALUE) {
    2089                 :         148 :             gjs_arg_set(arg, BoxedBase::to_c_ptr<GValue>(cx, obj));
    2090                 :         148 :             state->ignore_release.insert(arg);
    2091                 :         148 :             return true;
    2092                 :             :         }
    2093         [ +  + ]:         179 :     }
    2094                 :             : 
    2095                 :          60 :     Gjs::AutoGValue gvalue;
    2096                 :             : 
    2097         [ -  + ]:          60 :     if (!gjs_value_to_g_value(cx, value, &gvalue))
    2098                 :           0 :         return false;
    2099                 :             : 
    2100                 :          60 :     gjs_arg_set(arg, g_boxed_copy(G_TYPE_VALUE, &gvalue));
    2101                 :             : 
    2102                 :          60 :     return true;
    2103                 :          60 : }
    2104                 :             : 
    2105                 :             : GJS_JSAPI_RETURN_CONVENTION
    2106                 :       67211 : bool BoxedInTransferNone::in(JSContext* cx, GjsFunctionCallState* state,
    2107                 :             :                              GIArgument* arg, JS::HandleValue value) {
    2108         [ +  + ]:       67211 :     if (value.isNull())
    2109                 :       13614 :         return NullableIn::in(cx, state, arg, value);
    2110                 :             : 
    2111                 :       53597 :     GType gtype = RegisteredType::gtype();
    2112                 :             : 
    2113         [ -  + ]:       53597 :     if (!value.isObject())
    2114                 :           0 :         return report_gtype_mismatch(cx, m_arg_name, value, gtype);
    2115                 :             : 
    2116                 :       53597 :     JS::RootedObject object(cx, &value.toObject());
    2117         [ +  + ]:       53597 :     if (gtype == G_TYPE_ERROR) {
    2118                 :          12 :         return ErrorBase::transfer_to_gi_argument(cx, object, arg,
    2119                 :          12 :                                                   GI_DIRECTION_IN, m_transfer);
    2120                 :             :     }
    2121                 :             : 
    2122   [ -  +  -  -  :       53591 :     if (info() && !BoxedBase::typecheck(cx, object, info().ref())) {
          -  +  +  -  -  
                      + ]
    2123                 :           0 :         gjs_arg_unset(arg);
    2124                 :           0 :         return false;
    2125                 :             :     }
    2126                 :      107182 :     return BoxedBase::transfer_to_gi_argument(cx, object, arg, GI_DIRECTION_IN,
    2127                 :      107182 :                                               m_transfer, gtype);
    2128                 :       53597 : }
    2129                 :             : 
    2130                 :             : // Unions include ClutterEvent and GdkEvent, which occur fairly often in an
    2131                 :             : // interactive application, so they're worth a special case in a different
    2132                 :             : // virtual function.
    2133                 :             : GJS_JSAPI_RETURN_CONVENTION
    2134                 :           9 : bool UnionIn::in(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
    2135                 :             :                  JS::HandleValue value) {
    2136         [ -  + ]:           9 :     if (value.isNull())
    2137                 :           0 :         return NullableIn::in(cx, state, arg, value);
    2138                 :             : 
    2139                 :           9 :     GType gtype = RegisteredType::gtype();
    2140                 :             : 
    2141         [ -  + ]:           9 :     if (!value.isObject())
    2142                 :           0 :         return report_gtype_mismatch(cx, m_arg_name, value, gtype);
    2143                 :             : 
    2144                 :           9 :     JS::RootedObject object(cx, &value.toObject());
    2145                 :           9 :     return UnionBase::transfer_to_gi_argument(cx, object, arg, GI_DIRECTION_IN,
    2146                 :          18 :                                               m_transfer, gtype);
    2147                 :           9 : }
    2148                 :             : 
    2149                 :             : GJS_JSAPI_RETURN_CONVENTION
    2150                 :       13489 : bool GClosureInTransferNone::in(JSContext* cx, GjsFunctionCallState* state,
    2151                 :             :                                 GIArgument* arg, JS::HandleValue value) {
    2152         [ -  + ]:       13489 :     if (value.isNull())
    2153                 :           0 :         return NullableIn::in(cx, state, arg, value);
    2154                 :             : 
    2155         [ -  + ]:       13489 :     if (!(JS_TypeOfValue(cx, value) == JSTYPE_FUNCTION))
    2156                 :           0 :         return report_typeof_mismatch(cx, m_arg_name, value,
    2157                 :           0 :                                       ExpectedType::FUNCTION);
    2158                 :             : 
    2159                 :       13489 :     JS::RootedObject callable(cx, &value.toObject());
    2160                 :       13489 :     GClosure* closure = Gjs::Closure::create_marshaled(cx, callable, "boxed");
    2161                 :       13489 :     gjs_arg_set(arg, closure);
    2162                 :       13489 :     g_closure_ref(closure);
    2163                 :       13489 :     g_closure_sink(closure);
    2164                 :             : 
    2165                 :       13489 :     return true;
    2166                 :       13489 : }
    2167                 :             : 
    2168                 :             : GJS_JSAPI_RETURN_CONVENTION
    2169                 :          71 : bool GBytesIn::in(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
    2170                 :             :                   JS::HandleValue value) {
    2171         [ -  + ]:          71 :     if (value.isNull())
    2172                 :           0 :         return NullableIn::in(cx, state, arg, value);
    2173                 :             : 
    2174         [ -  + ]:          71 :     if (!value.isObject())
    2175                 :           0 :         return report_gtype_mismatch(cx, m_arg_name, value, G_TYPE_BYTES);
    2176                 :             : 
    2177                 :          71 :     JS::RootedObject object(cx, &value.toObject());
    2178         [ +  + ]:          71 :     if (JS_IsUint8Array(object)) {
    2179                 :          21 :         state->ignore_release.insert(arg);
    2180                 :          21 :         gjs_arg_set(arg, gjs_byte_array_get_bytes(object));
    2181                 :          21 :         return true;
    2182                 :             :     }
    2183                 :             : 
    2184                 :             :     // The bytearray path is taking an extra ref irrespective of transfer
    2185                 :             :     // ownership, so we need to do the same here.
    2186                 :         100 :     return BoxedBase::transfer_to_gi_argument(
    2187                 :          50 :         cx, object, arg, GI_DIRECTION_IN, GI_TRANSFER_EVERYTHING, G_TYPE_BYTES);
    2188                 :          71 : }
    2189                 :             : 
    2190                 :             : GJS_JSAPI_RETURN_CONVENTION
    2191                 :          35 : bool GBytesIn::release(JSContext* cx, GjsFunctionCallState* state,
    2192                 :             :                        GIArgument* in_arg, GIArgument* out_arg) {
    2193         [ -  + ]:          35 :     if (state->ignore_release.erase(in_arg))
    2194                 :           0 :         return BoxedIn::release(cx, state, in_arg, out_arg);
    2195                 :             : 
    2196                 :          35 :     return BoxedInTransferNone::release(cx, state, in_arg, out_arg);
    2197                 :             : }
    2198                 :             : 
    2199                 :             : GJS_JSAPI_RETURN_CONVENTION
    2200                 :           4 : bool InterfaceIn::in(JSContext* cx, GjsFunctionCallState* state,
    2201                 :             :                      GIArgument* arg, JS::HandleValue value) {
    2202         [ -  + ]:           4 :     if (value.isNull())
    2203                 :           0 :         return NullableIn::in(cx, state, arg, value);
    2204                 :             : 
    2205                 :           4 :     GType gtype = RegisteredType::gtype();
    2206                 :             : 
    2207         [ -  + ]:           4 :     if (!value.isObject())
    2208                 :           0 :         return report_gtype_mismatch(cx, m_arg_name, value, gtype);
    2209                 :             : 
    2210                 :           4 :     JS::RootedObject object(cx, &value.toObject());
    2211                 :             : 
    2212                 :             :     // Could be a GObject interface that's missing a prerequisite,
    2213                 :             :     // or could be a fundamental
    2214         [ +  - ]:           4 :     if (ObjectBase::typecheck(cx, object, gtype, GjsTypecheckNoThrow{})) {
    2215                 :           8 :         return ObjectBase::transfer_to_gi_argument(
    2216                 :           8 :             cx, object, arg, GI_DIRECTION_IN, m_transfer, gtype);
    2217                 :             :     }
    2218                 :             : 
    2219                 :             :     // If this typecheck fails, then it's neither an object nor a
    2220                 :             :     // fundamental
    2221                 :           0 :     return FundamentalBase::transfer_to_gi_argument(
    2222                 :           0 :         cx, object, arg, GI_DIRECTION_IN, m_transfer, gtype);
    2223                 :           4 : }
    2224                 :             : 
    2225                 :             : GJS_JSAPI_RETURN_CONVENTION
    2226                 :        2337 : bool ObjectIn::in(JSContext* cx, GjsFunctionCallState* state, GIArgument* arg,
    2227                 :             :                   JS::HandleValue value) {
    2228         [ +  + ]:        2337 :     if (value.isNull())
    2229                 :         289 :         return NullableIn::in(cx, state, arg, value);
    2230                 :             : 
    2231                 :        2048 :     GType gtype = RegisteredType::gtype();
    2232                 :             : 
    2233         [ -  + ]:        2048 :     if (!value.isObject())
    2234                 :           0 :         return report_gtype_mismatch(cx, m_arg_name, value, gtype);
    2235                 :             : 
    2236                 :        2048 :     JS::RootedObject object(cx, &value.toObject());
    2237                 :        2048 :     return ObjectBase::transfer_to_gi_argument(cx, object, arg, GI_DIRECTION_IN,
    2238                 :        4096 :                                                m_transfer, gtype);
    2239                 :        2048 : }
    2240                 :             : 
    2241                 :             : GJS_JSAPI_RETURN_CONVENTION
    2242                 :           6 : bool FundamentalIn::in(JSContext* cx, GjsFunctionCallState* state,
    2243                 :             :                        GIArgument* arg, JS::HandleValue value) {
    2244         [ -  + ]:           6 :     if (value.isNull())
    2245                 :           0 :         return NullableIn::in(cx, state, arg, value);
    2246                 :             : 
    2247                 :           6 :     GType gtype = RegisteredType::gtype();
    2248                 :             : 
    2249         [ -  + ]:           6 :     if (!value.isObject())
    2250                 :           0 :         return report_gtype_mismatch(cx, m_arg_name, value, gtype);
    2251                 :             : 
    2252                 :           6 :     JS::RootedObject object(cx, &value.toObject());
    2253                 :           6 :     return FundamentalBase::transfer_to_gi_argument(
    2254                 :          12 :         cx, object, arg, GI_DIRECTION_IN, m_transfer, gtype);
    2255                 :           6 : }
    2256                 :             : 
    2257                 :             : GJS_JSAPI_RETURN_CONVENTION
    2258                 :          86 : bool GTypeStructInstanceIn::in(JSContext* cx, GjsFunctionCallState*,
    2259                 :             :                                GIArgument* arg, JS::HandleValue value) {
    2260                 :             :     // Instance parameter is never nullable
    2261         [ -  + ]:          86 :     if (!value.isObject())
    2262                 :           0 :         return report_typeof_mismatch(cx, m_arg_name, value,
    2263                 :           0 :                                       ExpectedType::OBJECT);
    2264                 :             : 
    2265                 :          86 :     JS::RootedObject obj(cx, &value.toObject());
    2266                 :             :     GType actual_gtype;
    2267         [ -  + ]:          86 :     if (!gjs_gtype_get_actual_gtype(cx, obj, &actual_gtype))
    2268                 :           0 :         return false;
    2269                 :             : 
    2270         [ -  + ]:          86 :     if (actual_gtype == G_TYPE_NONE) {
    2271                 :           0 :         gjs_throw(cx, "Invalid GType class passed for instance parameter");
    2272                 :           0 :         return false;
    2273                 :             :     }
    2274                 :             : 
    2275                 :             :     // We use peek here to simplify reference counting (we just ignore transfer
    2276                 :             :     // annotation, as GType classes are never really freed.) We know that the
    2277                 :             :     // GType class is referenced at least once when the JS constructor is
    2278                 :             :     // initialized.
    2279   [ +  -  -  +  :          86 :     if (g_type_is_a(actual_gtype, G_TYPE_INTERFACE))
                   -  + ]
    2280                 :           0 :         gjs_arg_set(arg, g_type_default_interface_peek(actual_gtype));
    2281                 :             :     else
    2282                 :          86 :         gjs_arg_set(arg, g_type_class_peek(actual_gtype));
    2283                 :             : 
    2284                 :          86 :     return true;
    2285                 :          86 : }
    2286                 :             : 
    2287                 :             : GJS_JSAPI_RETURN_CONVENTION
    2288                 :         161 : bool ParamInstanceIn::in(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
    2289                 :             :                          JS::HandleValue value) {
    2290                 :             :     // Instance parameter is never nullable
    2291         [ -  + ]:         161 :     if (!value.isObject())
    2292                 :           0 :         return report_typeof_mismatch(cx, m_arg_name, value,
    2293                 :           0 :                                       ExpectedType::OBJECT);
    2294                 :             : 
    2295                 :         161 :     JS::RootedObject obj(cx, &value.toObject());
    2296         [ -  + ]:         161 :     if (!gjs_typecheck_param(cx, obj, G_TYPE_PARAM, true))
    2297                 :           0 :         return false;
    2298                 :         161 :     gjs_arg_set(arg, gjs_g_param_from_param(cx, obj));
    2299                 :             : 
    2300         [ -  + ]:         161 :     if (m_transfer == GI_TRANSFER_EVERYTHING)
    2301                 :           0 :         g_param_spec_ref(gjs_arg_get<GParamSpec*>(arg));
    2302                 :             : 
    2303                 :         161 :     return true;
    2304                 :         161 : }
    2305                 :             : 
    2306                 :             : GJS_JSAPI_RETURN_CONVENTION
    2307                 :       21700 : bool FallbackInOut::out(JSContext* cx, GjsFunctionCallState*, GIArgument* arg,
    2308                 :             :                         JS::MutableHandleValue value) {
    2309                 :       21700 :     return gjs_value_from_gi_argument(cx, value, m_type_info, arg, true);
    2310                 :             : }
    2311                 :             : 
    2312                 :             : GJS_JSAPI_RETURN_CONVENTION
    2313                 :          12 : bool CArrayInOut::out(JSContext* cx, GjsFunctionCallState* state,
    2314                 :             :                       GIArgument* arg, JS::MutableHandleValue value) {
    2315                 :             :     GIArgument* length_arg;
    2316                 :             : 
    2317         [ +  - ]:          12 :     if (m_length_direction != GI_DIRECTION_IN)
    2318                 :          12 :         length_arg = &(state->out_cvalue(m_length_pos));
    2319                 :             :     else
    2320                 :           0 :         length_arg = &(state->in_cvalue(m_length_pos));
    2321                 :             : 
    2322                 :          12 :     size_t length = gjs_gi_argument_get_array_length(m_tag, length_arg);
    2323                 :             : 
    2324                 :          24 :     return gjs_value_from_explicit_array(cx, value, m_type_info, m_transfer,
    2325                 :          12 :                                          arg, length);
    2326                 :             : }
    2327                 :             : 
    2328                 :             : GJS_JSAPI_RETURN_CONVENTION
    2329                 :           3 : bool FallbackIn::release(JSContext* cx, GjsFunctionCallState* state,
    2330                 :             :                          GIArgument* in_arg, GIArgument*) {
    2331                 :             :     GITransfer transfer =
    2332         [ +  - ]:           3 :         state->call_completed() ? m_transfer : GI_TRANSFER_NOTHING;
    2333                 :           3 :     return gjs_gi_argument_release_in_arg(cx, transfer, m_type_info, in_arg);
    2334                 :             : }
    2335                 :             : 
    2336                 :             : GJS_JSAPI_RETURN_CONVENTION
    2337                 :       21679 : bool FallbackOut::release(JSContext* cx, GjsFunctionCallState*,
    2338                 :             :                           GIArgument* in_arg [[maybe_unused]],
    2339                 :             :                           GIArgument* out_arg) {
    2340                 :       21679 :     return gjs_gi_argument_release(cx, m_transfer, m_type_info, out_arg);
    2341                 :             : }
    2342                 :             : 
    2343                 :             : GJS_JSAPI_RETURN_CONVENTION
    2344                 :           7 : bool FallbackInOut::release(JSContext* cx, GjsFunctionCallState* state,
    2345                 :             :                             GIArgument*, GIArgument* out_arg) {
    2346                 :             :     GITransfer transfer =
    2347         [ +  - ]:           7 :         state->call_completed() ? m_transfer : GI_TRANSFER_NOTHING;
    2348                 :           7 :     GIArgument* original_out_arg = &state->inout_original_cvalue(m_arg_pos);
    2349                 :             : 
    2350                 :             :     // Assume that inout transfer means that in and out transfer are the same.
    2351                 :             :     // See https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/192
    2352                 :             : 
    2353         [ +  + ]:          13 :     if (gjs_arg_get<void*>(original_out_arg) != gjs_arg_get<void*>(out_arg) &&
    2354   [ -  +  -  + ]:          13 :         !gjs_gi_argument_release_in_arg(cx, transfer, m_type_info,
    2355                 :             :                                         original_out_arg))
    2356                 :           0 :         return false;
    2357                 :             : 
    2358                 :           7 :     return gjs_gi_argument_release(cx, transfer, m_type_info, out_arg);
    2359                 :             : }
    2360                 :             : 
    2361                 :             : GJS_JSAPI_RETURN_CONVENTION
    2362                 :          10 : bool CArrayOut::release(JSContext* cx, GjsFunctionCallState* state,
    2363                 :             :                         GIArgument* in_arg [[maybe_unused]],
    2364                 :             :                         GIArgument* out_arg) {
    2365                 :          10 :     GIArgument* length_arg = &state->out_cvalue(m_length_pos);
    2366                 :          10 :     size_t length = gjs_gi_argument_get_array_length(m_tag, length_arg);
    2367                 :             : 
    2368                 :          20 :     return gjs_gi_argument_release_out_array(cx, m_transfer, m_type_info,
    2369                 :          10 :                                              length, out_arg);
    2370                 :             : }
    2371                 :             : 
    2372                 :             : GJS_JSAPI_RETURN_CONVENTION
    2373                 :         244 : bool CArrayIn::release(JSContext* cx, GjsFunctionCallState* state,
    2374                 :             :                        GIArgument* in_arg,
    2375                 :             :                        GIArgument* out_arg [[maybe_unused]]) {
    2376                 :         244 :     GIArgument* length_arg = &state->in_cvalue(m_length_pos);
    2377                 :         244 :     size_t length = gjs_gi_argument_get_array_length(m_tag, length_arg);
    2378                 :             : 
    2379                 :             :     GITransfer transfer =
    2380         [ +  - ]:         244 :         state->call_completed() ? m_transfer : GI_TRANSFER_NOTHING;
    2381                 :             : 
    2382                 :         488 :     return gjs_gi_argument_release_in_array(cx, transfer, m_type_info, length,
    2383                 :         244 :                                             in_arg);
    2384                 :             : }
    2385                 :             : 
    2386                 :             : GJS_JSAPI_RETURN_CONVENTION
    2387                 :           2 : bool CArrayInOut::release(JSContext* cx, GjsFunctionCallState* state,
    2388                 :             :                           GIArgument* in_arg [[maybe_unused]],
    2389                 :             :                           GIArgument* out_arg) {
    2390                 :           2 :     GIArgument* length_arg = &state->out_cvalue(m_length_pos);
    2391                 :           2 :     size_t length = gjs_gi_argument_get_array_length(m_tag, length_arg);
    2392                 :             :     GITransfer transfer =
    2393         [ +  - ]:           2 :         state->call_completed() ? m_transfer : GI_TRANSFER_NOTHING;
    2394                 :             : 
    2395                 :           2 :     GIArgument* original_out_arg = &state->inout_original_cvalue(m_arg_pos);
    2396                 :             :     // Due to https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/192
    2397                 :             :     // Here we've to guess what to do, but in general is "better" to leak than
    2398                 :             :     // crash, so let's assume that in/out transfer is matching.
    2399         [ +  - ]:           2 :     if (gjs_arg_get<void*>(original_out_arg) != gjs_arg_get<void*>(out_arg)) {
    2400         [ -  + ]:           2 :         if (!gjs_gi_argument_release_in_array(cx, transfer, m_type_info, length,
    2401                 :             :                                               original_out_arg))
    2402                 :           0 :             return false;
    2403                 :             :     }
    2404                 :             : 
    2405                 :           4 :     return gjs_gi_argument_release_out_array(cx, transfer, m_type_info, length,
    2406                 :           2 :                                              out_arg);
    2407                 :             : }
    2408                 :             : 
    2409                 :             : GJS_JSAPI_RETURN_CONVENTION
    2410                 :           6 : bool CallerAllocatesOut::release(JSContext*, GjsFunctionCallState*,
    2411                 :             :                                  GIArgument* in_arg,
    2412                 :             :                                  GIArgument* out_arg [[maybe_unused]]) {
    2413                 :           6 :     g_free(gjs_arg_steal<void*>(in_arg));
    2414                 :           6 :     return true;
    2415                 :             : }
    2416                 :             : 
    2417                 :             : GJS_JSAPI_RETURN_CONVENTION
    2418                 :           4 : bool BoxedCallerAllocatesOut::release(JSContext*, GjsFunctionCallState*,
    2419                 :             :                                       GIArgument* in_arg, GIArgument*) {
    2420                 :           4 :     g_boxed_free(m_gtype, gjs_arg_steal<void*>(in_arg));
    2421                 :           4 :     return true;
    2422                 :             : }
    2423                 :             : 
    2424                 :             : GJS_JSAPI_RETURN_CONVENTION
    2425                 :         260 : bool CallbackIn::release(JSContext*, GjsFunctionCallState*, GIArgument* in_arg,
    2426                 :             :                          GIArgument* out_arg [[maybe_unused]]) {
    2427                 :         260 :     ffi_closure *closure = m_ffi_closure;
    2428         [ +  + ]:         260 :     if (!closure)
    2429                 :          10 :         return true;
    2430                 :             : 
    2431                 :         250 :     g_closure_unref(static_cast<GClosure*>(closure->user_data));
    2432                 :             :     // CallbackTrampolines are refcounted because for notified/async closures
    2433                 :             :     // it is possible to destroy it while in call, and therefore we cannot
    2434                 :             :     // check its scope at this point
    2435                 :         250 :     gjs_arg_unset(in_arg);
    2436                 :         250 :     return true;
    2437                 :             : }
    2438                 :             : 
    2439                 :             : template <GITypeTag TAG>
    2440                 :        5037 : GJS_JSAPI_RETURN_CONVENTION bool StringInTransferNone<TAG>::release(
    2441                 :             :     JSContext*, GjsFunctionCallState*, GIArgument* in_arg,
    2442                 :             :     GIArgument* out_arg [[maybe_unused]]) {
    2443                 :        5037 :     g_free(gjs_arg_get<void*>(in_arg));
    2444                 :        5037 :     return true;
    2445                 :             : }
    2446                 :             : 
    2447                 :             : GJS_JSAPI_RETURN_CONVENTION
    2448                 :           9 : bool ForeignStructIn::release(JSContext* cx, GjsFunctionCallState* state,
    2449                 :             :                               GIArgument* in_arg,
    2450                 :             :                               GIArgument* out_arg [[maybe_unused]]) {
    2451                 :             :     GITransfer transfer =
    2452         [ +  - ]:           9 :         state->call_completed() ? m_transfer : GI_TRANSFER_NOTHING;
    2453                 :             : 
    2454         [ +  + ]:           9 :     if (transfer == GI_TRANSFER_NOTHING)
    2455                 :           8 :         return gjs_struct_foreign_release_gi_argument(cx, m_transfer, m_info,
    2456                 :           4 :                                                       in_arg);
    2457                 :             : 
    2458                 :           5 :     return true;
    2459                 :             : }
    2460                 :             : 
    2461                 :             : GJS_JSAPI_RETURN_CONVENTION
    2462                 :       13620 : bool BoxedInTransferNone::release(JSContext*, GjsFunctionCallState*,
    2463                 :             :                                   GIArgument* in_arg,
    2464                 :             :                                   GIArgument* out_arg [[maybe_unused]]) {
    2465                 :       13620 :     GType gtype = RegisteredType::gtype();
    2466                 :       13620 :     g_assert(g_type_is_a(gtype, G_TYPE_BOXED));
    2467                 :             : 
    2468         [ -  + ]:       13620 :     if (!gjs_arg_get<void*>(in_arg))
    2469                 :           0 :         return true;
    2470                 :             : 
    2471                 :       13620 :     g_boxed_free(gtype, gjs_arg_get<void*>(in_arg));
    2472                 :       13620 :     return true;
    2473                 :             : }
    2474                 :             : 
    2475                 :             : GJS_JSAPI_RETURN_CONVENTION
    2476                 :         208 : bool GValueInTransferNone::release(JSContext* cx, GjsFunctionCallState* state,
    2477                 :             :                                    GIArgument* in_arg, GIArgument* out_arg) {
    2478         [ +  + ]:         208 :     if (state->ignore_release.erase(in_arg))
    2479                 :         148 :         return true;
    2480                 :             : 
    2481                 :          60 :     return BoxedInTransferNone::release(cx, state, in_arg, out_arg);
    2482                 :             : }
    2483                 :             : 
    2484                 :             : }  // namespace Arg
    2485                 :             : 
    2486                 :           0 : bool Argument::invalid(JSContext* cx, const char* func) const {
    2487         [ #  # ]:           0 :     gjs_throw(cx, "%s not implemented", func ? func : "Function");
    2488                 :           0 :     return false;
    2489                 :             : }
    2490                 :             : 
    2491                 :           0 : bool Argument::in(JSContext* cx, GjsFunctionCallState*, GIArgument*,
    2492                 :             :                   JS::HandleValue) {
    2493                 :           0 :     return invalid(cx, G_STRFUNC);
    2494                 :             : }
    2495                 :             : 
    2496                 :           0 : bool Argument::out(JSContext* cx, GjsFunctionCallState*, GIArgument*,
    2497                 :             :                    JS::MutableHandleValue) {
    2498                 :           0 :     return invalid(cx, G_STRFUNC);
    2499                 :             : }
    2500                 :             : 
    2501                 :           0 : bool Argument::release(JSContext*, GjsFunctionCallState*, GIArgument*,
    2502                 :             :                        GIArgument*) {
    2503                 :           0 :     return true;
    2504                 :             : }
    2505                 :             : 
    2506                 :             : // This is a trick to print out the sizes of the structs at compile time, in
    2507                 :             : // an error message:
    2508                 :             : // template <int s> struct Measure;
    2509                 :             : // Measure<sizeof(Arg::)> arg_size;
    2510                 :             : 
    2511                 :             : #ifdef GJS_DO_ARGUMENTS_SIZE_CHECK
    2512                 :             : template <typename T>
    2513                 :             : constexpr size_t argument_maximum_size() {
    2514                 :             :     if constexpr (std::is_same_v<T, Arg::BasicTypeInOut> ||
    2515                 :             :                   std::is_same_v<T, Arg::BasicTypeOut> ||
    2516                 :             :                   std::is_same_v<T, Arg::BasicTypeReturn> ||
    2517                 :             :                   std::is_same_v<T, Arg::ByteArrayIn> ||
    2518                 :             :                   std::is_same_v<T, Arg::ByteArrayInOut> ||
    2519                 :             :                   std::is_same_v<T, Arg::ByteArrayOut> ||
    2520                 :             :                   std::is_same_v<T, Arg::ByteArrayReturn> ||
    2521                 :             :                   std::is_same_v<T, Arg::ErrorIn> ||
    2522                 :             :                   std::is_same_v<T, Arg::GdkAtomIn> ||
    2523                 :             :                   std::is_same_v<T, Arg::NumericIn<int>> ||
    2524                 :             :                   std::is_same_v<T, Arg::NumericInOut<int>> ||
    2525                 :             :                   std::is_same_v<T, Arg::NumericOut<int>> ||
    2526                 :             :                   std::is_same_v<T, Arg::NumericReturn<int>> ||
    2527                 :             :                   std::is_same_v<T, Arg::SimpleOut> ||
    2528                 :             :                   std::is_same_v<T, Arg::SkipAll>)
    2529                 :             :         return 24;
    2530                 :             :     if constexpr (std::is_same_v<T, Arg::BasicExplicitCArrayIn> ||
    2531                 :             :                   std::is_same_v<T, Arg::BasicExplicitCArrayInOut> ||
    2532                 :             :                   std::is_same_v<T, Arg::BasicExplicitCArrayOut> ||
    2533                 :             :                   std::is_same_v<T, Arg::BasicGHashIn> ||
    2534                 :             :                   std::is_same_v<T, Arg::BasicGHashInOut> ||
    2535                 :             :                   std::is_same_v<T, Arg::BasicGHashOut> ||
    2536                 :             :                   std::is_same_v<T, Arg::BasicGHashReturn> ||
    2537                 :             :                   std::is_same_v<T, Arg::BoxedIn> ||
    2538                 :             :                   std::is_same_v<T, Arg::FundamentalIn> ||
    2539                 :             :                   std::is_same_v<T, Arg::GBytesIn> ||
    2540                 :             :                   std::is_same_v<T, Arg::GBytesInTransferNone> ||
    2541                 :             :                   std::is_same_v<T, Arg::GClosureIn> ||
    2542                 :             :                   std::is_same_v<T, Arg::GClosureInTransferNone> ||
    2543                 :             :                   std::is_same_v<T, Arg::GValueIn> ||
    2544                 :             :                   std::is_same_v<T, Arg::GValueInTransferNone> ||
    2545                 :             :                   std::is_same_v<T, Arg::InterfaceIn> ||
    2546                 :             :                   std::is_same_v<T, Arg::ObjectIn> ||
    2547                 :             :                   std::is_same_v<T, Arg::UnionIn>)
    2548                 :             :         return 40;
    2549                 :             :     if constexpr (std::is_same_v<T, Arg::FallbackInterfaceIn> ||
    2550                 :             :                   std::is_same_v<T, Arg::ForeignStructIn> ||
    2551                 :             :                   std::is_same_v<T, Arg::ForeignStructInstanceIn> ||
    2552                 :             :                   std::is_same_v<T, Arg::UnregisteredBoxedIn>)
    2553                 :             :         return 48;
    2554                 :             :     if constexpr (std::is_same_v<T, Arg::CallbackIn>)
    2555                 :             :         return 56;
    2556                 :             :     if constexpr (std::is_same_v<T, Arg::CArrayIn> ||
    2557                 :             :                   std::is_same_v<T, Arg::CArrayInOut> ||
    2558                 :             :                   std::is_same_v<T, Arg::CArrayInOut> ||
    2559                 :             :                   std::is_same_v<T, Arg::CArrayOut> ||
    2560                 :             :                   std::is_same_v<T, Arg::FallbackInOut> ||
    2561                 :             :                   std::is_same_v<T, Arg::FallbackOut> ||
    2562                 :             :                   std::is_same_v<T, Arg::FallbackReturn> ||
    2563                 :             :                   std::is_same_v<T, Arg::FixedSizeArrayInOut> ||
    2564                 :             :                   std::is_same_v<T, Arg::ZeroTerminatedArrayInOut>)
    2565                 :             :         return 104;
    2566                 :             :     if constexpr (std::is_same_v<T, Arg::CallerAllocatesOut> ||
    2567                 :             :                   std::is_same_v<T, Arg::FallbackIn> ||
    2568                 :             :                   std::is_same_v<T, Arg::FixedSizeArrayIn> ||
    2569                 :             :                   std::is_same_v<T, Arg::ZeroTerminatedArrayIn>)
    2570                 :             :         return 112;
    2571                 :             :     if constexpr (std::is_same_v<T, Arg::BoxedCallerAllocatesOut>)
    2572                 :             :         return 120;
    2573                 :             :     else
    2574                 :             :         return 32;
    2575                 :             : }
    2576                 :             : #endif
    2577                 :             : 
    2578                 :             : template <typename T, Arg::Kind ArgKind>
    2579                 :       35991 : void Argument::init_common(const Init& init, T* arg) {
    2580                 :             : #ifdef GJS_DO_ARGUMENTS_SIZE_CHECK
    2581                 :             :     static_assert(
    2582                 :             :         sizeof(T) <= argument_maximum_size<T>(),
    2583                 :             :         "Think very hard before increasing the size of Gjs::Arguments. "
    2584                 :             :         "One is allocated for every argument to every introspected function.");
    2585                 :             : #endif
    2586                 :             :     if constexpr (ArgKind == Arg::Kind::INSTANCE) {
    2587                 :        3609 :         g_assert(init.index == Argument::ABSENT &&
    2588                 :             :                  "index was ignored in INSTANCE parameter");
    2589                 :        3609 :         g_assert(init.name == nullptr &&
    2590                 :             :                  "name was ignored in INSTANCE parameter");
    2591                 :        3609 :         arg->set_instance_parameter();
    2592                 :             :     } else if constexpr (ArgKind == Arg::Kind::RETURN_VALUE) {
    2593                 :        9374 :         g_assert(init.index == Argument::ABSENT &&
    2594                 :             :                  "index was ignored in RETURN_VALUE parameter");
    2595                 :        9374 :         g_assert(init.name == nullptr &&
    2596                 :             :                  "name was ignored in RETURN_VALUE parameter");
    2597                 :        9374 :         arg->set_return_value();
    2598                 :             :     } else {
    2599                 :             :         if constexpr (std::is_base_of_v<Arg::Positioned, T>)
    2600                 :        1773 :             arg->set_arg_pos(init.index);
    2601                 :       23008 :         arg->m_arg_name = init.name;
    2602                 :             :     }
    2603                 :             : 
    2604                 :       35991 :     arg->m_skip_in = (init.flags & GjsArgumentFlags::SKIP_IN);
    2605                 :       35991 :     arg->m_skip_out = (init.flags & GjsArgumentFlags::SKIP_OUT);
    2606                 :             : 
    2607                 :             :     if constexpr (std::is_base_of_v<Arg::Nullable, T>)
    2608                 :       19499 :         arg->m_nullable = (init.flags & GjsArgumentFlags::MAY_BE_NULL);
    2609                 :             : 
    2610                 :             :     if constexpr (std::is_base_of_v<Arg::Transferable, T>)
    2611                 :       14222 :         arg->m_transfer = init.transfer;
    2612                 :       35991 : }
    2613                 :             : 
    2614                 :       11935 : bool ArgsCache::initialize(JSContext* cx, const GI::CallableInfo callable) {
    2615         [ -  + ]:       11935 :     if (m_args) {
    2616                 :           0 :         gjs_throw(cx, "Arguments cache already initialized!");
    2617                 :           0 :         return false;
    2618                 :             :     }
    2619                 :             : 
    2620                 :       11935 :     GI::StackTypeInfo type_info;
    2621                 :       11935 :     callable.load_return_type(&type_info);
    2622                 :             : 
    2623                 :       11935 :     m_has_return =
    2624   [ +  +  +  + ]:       11935 :         type_info.tag() != GI_TYPE_TAG_VOID || type_info.is_pointer();
    2625                 :       11935 :     m_is_method = callable.is_method();
    2626                 :             : 
    2627                 :       11935 :     int size = callable.n_args();
    2628         [ +  + ]:       11935 :     size += (m_is_method ? 1 : 0);
    2629         [ +  + ]:       11935 :     size += (m_has_return ? 1 : 0);
    2630                 :             : 
    2631         [ -  + ]:       11935 :     if (size > Argument::MAX_ARGS) {
    2632                 :           0 :         gjs_throw(cx,
    2633                 :             :                   "Too many arguments, only %u are supported, while %d are "
    2634                 :             :                   "provided!",
    2635                 :             :                   Argument::MAX_ARGS, size);
    2636                 :           0 :         return false;
    2637                 :             :     }
    2638                 :             : 
    2639   [ +  -  +  + ]:       47670 :     m_args = new ArgumentPtr[size]{};
    2640                 :       11935 :     return true;
    2641                 :             : }
    2642                 :             : 
    2643                 :             : template <Arg::Kind ArgKind, typename T>
    2644                 :       35991 : constexpr void ArgsCache::set_argument(T* arg, const Argument::Init& init) {
    2645                 :       35991 :     Argument::init_common<T, ArgKind>(init, arg);
    2646                 :       35991 :     arg_get<ArgKind>(init.index) = arg;
    2647                 :       35991 : }
    2648                 :             : 
    2649                 :             : template <typename T>
    2650                 :        9374 : constexpr void ArgsCache::set_return(T* arg, GITransfer transfer,
    2651                 :             :                                      GjsArgumentFlags flags) {
    2652                 :       18748 :     set_argument<Arg::Kind::RETURN_VALUE>(
    2653                 :        9374 :         arg, Argument::Init{nullptr, Argument::ABSENT, transfer, flags});
    2654                 :        9374 : }
    2655                 :             : 
    2656                 :             : template <typename T>
    2657                 :         589 : constexpr void ArgsCache::set_instance(T* arg, GITransfer transfer,
    2658                 :             :                                        GjsArgumentFlags flags) {
    2659                 :        1178 :     set_argument<Arg::Kind::INSTANCE>(
    2660                 :         589 :         arg, Argument::Init{nullptr, Argument::ABSENT, transfer, flags});
    2661                 :         589 : }
    2662                 :             : 
    2663                 :       40101 : Maybe<GType> ArgsCache::instance_type() const {
    2664                 :       40101 :     return instance()
    2665                 :       40101 :         .andThen(std::mem_fn(&Argument::as_instance))
    2666                 :       40101 :         .map(std::mem_fn(&Arg::Instance::gtype));
    2667                 :             : }
    2668                 :             : 
    2669                 :       73452 : Maybe<Arg::ReturnTag> ArgsCache::return_tag() const {
    2670                 :       73452 :     return return_value().andThen(std::mem_fn(&Argument::return_tag));
    2671                 :             : }
    2672                 :             : 
    2673                 :        1740 : void ArgsCache::set_skip_all(uint8_t index, const char* name) {
    2674                 :        1740 :     set_argument(new Arg::SkipAll(),
    2675                 :        1740 :                  Argument::Init{name, index, GI_TRANSFER_NOTHING,
    2676                 :             :                                 GjsArgumentFlags::SKIP_ALL});
    2677                 :        1740 : }
    2678                 :             : 
    2679                 :         183 : void ArgsCache::init_out_array_length_argument(const GI::ArgInfo length_arg,
    2680                 :             :                                                GjsArgumentFlags flags,
    2681                 :             :                                                unsigned length_pos) {
    2682                 :             :     // Even if we skip the length argument most of time, we need to do some
    2683                 :             :     // basic initialization here.
    2684                 :         183 :     g_assert(length_pos <= Argument::MAX_ARGS && "too many arguments");
    2685                 :         183 :     uint8_t validated_length_pos = length_pos;
    2686                 :         183 :     set_argument(
    2687                 :         183 :         new Arg::ArrayLengthOut(),
    2688                 :         549 :         Argument::Init{
    2689                 :         183 :             length_arg.name(), validated_length_pos, GI_TRANSFER_NOTHING,
    2690                 :         183 :             static_cast<GjsArgumentFlags>(flags | GjsArgumentFlags::SKIP_ALL)});
    2691                 :         183 : }
    2692                 :             : 
    2693                 :         963 : void ArgsCache::set_array_argument(const GI::CallableInfo callable,
    2694                 :             :                                    uint8_t gi_index,
    2695                 :             :                                    const GI::TypeInfo type_info,
    2696                 :             :                                    GIDirection direction, const GI::ArgInfo arg,
    2697                 :             :                                    GjsArgumentFlags flags,
    2698                 :             :                                    unsigned length_pos) {
    2699                 :         963 :     g_assert(type_info.array_type() == GI_ARRAY_TYPE_C);
    2700                 :             : 
    2701                 :         963 :     GI::AutoTypeInfo element_type{type_info.element_type()};
    2702                 :             : 
    2703                 :         963 :     GI::StackArgInfo length_arg;
    2704                 :         963 :     callable.load_arg(length_pos, &length_arg);
    2705                 :         963 :     GI::StackTypeInfo length_type;
    2706                 :         963 :     length_arg.load_type(&length_type);
    2707                 :         963 :     GITypeTag length_tag = length_type.tag();
    2708                 :         963 :     GIDirection length_direction = length_arg.direction();
    2709                 :             : 
    2710                 :         963 :     Argument::Init common_args{arg.name(), gi_index, arg.ownership_transfer(),
    2711                 :         963 :                                flags};
    2712                 :             : 
    2713         [ +  + ]:         963 :     if (direction == GI_DIRECTION_IN) {
    2714         [ +  + ]:         907 :         if (element_type.is_basic()) {
    2715                 :         585 :             set_argument(
    2716                 :             :                 new Arg::BasicExplicitCArrayIn(element_type.tag(), length_pos,
    2717                 :         585 :                                                length_tag, length_direction),
    2718                 :             :                 common_args);
    2719                 :             :         } else {
    2720                 :         322 :             set_argument(new Arg::CArrayIn(type_info, length_pos, length_tag,
    2721                 :         644 :                                            length_direction),
    2722                 :             :                          common_args);
    2723                 :             :         }
    2724                 :         907 :         set_skip_all(length_pos, length_arg.name());
    2725         [ +  + ]:          56 :     } else if (direction == GI_DIRECTION_INOUT) {
    2726         [ +  + ]:          25 :         if (element_type.is_basic()) {
    2727                 :          22 :             set_argument(new Arg::BasicExplicitCArrayInOut(
    2728                 :             :                              element_type.tag(), length_pos, length_tag,
    2729                 :          22 :                              length_direction),
    2730                 :             :                          common_args);
    2731                 :             :         } else {
    2732                 :           3 :             set_argument(new Arg::CArrayInOut(type_info, length_pos, length_tag,
    2733                 :           6 :                                               length_direction),
    2734                 :             :                          common_args);
    2735                 :             :         }
    2736                 :          25 :         set_skip_all(length_pos, length_arg.name());
    2737                 :             :     } else {
    2738         [ +  + ]:          31 :         if (element_type.is_basic()) {
    2739                 :          23 :             set_argument(
    2740                 :             :                 new Arg::BasicExplicitCArrayOut(element_type.tag(), length_pos,
    2741                 :          23 :                                                 length_tag, length_direction),
    2742                 :             :                 common_args);
    2743                 :             :         } else {
    2744                 :           8 :             set_argument(new Arg::CArrayOut(type_info, length_pos, length_tag,
    2745                 :          16 :                                             length_direction),
    2746                 :             :                          common_args);
    2747                 :             :         }
    2748                 :             :     }
    2749                 :             : 
    2750         [ +  + ]:         963 :     if (direction == GI_DIRECTION_OUT)
    2751                 :          31 :         init_out_array_length_argument(length_arg, flags, length_pos);
    2752                 :         963 : }
    2753                 :             : 
    2754                 :         152 : void ArgsCache::set_array_return(const GI::CallableInfo callable,
    2755                 :             :                                  const GI::TypeInfo type_info,
    2756                 :             :                                  GjsArgumentFlags flags, unsigned length_pos) {
    2757                 :         152 :     g_assert(type_info.array_type() == GI_ARRAY_TYPE_C);
    2758                 :             : 
    2759                 :         152 :     GI::AutoTypeInfo element_type{type_info.element_type()};
    2760                 :             : 
    2761                 :         152 :     GI::StackArgInfo length_arg;
    2762                 :         152 :     callable.load_arg(length_pos, &length_arg);
    2763                 :         152 :     GI::StackTypeInfo length_type;
    2764                 :         152 :     length_arg.load_type(&length_type);
    2765                 :         152 :     GITypeTag length_tag = length_type.tag();
    2766                 :         152 :     GIDirection length_direction = length_arg.direction();
    2767                 :             : 
    2768                 :         152 :     GITransfer transfer = callable.caller_owns();
    2769         [ +  + ]:         152 :     if (element_type.is_basic()) {
    2770                 :          14 :         set_return(
    2771                 :             :             new Arg::BasicExplicitCArrayOut(element_type.tag(), length_pos,
    2772                 :          14 :                                             length_tag, length_direction),
    2773                 :             :             transfer, GjsArgumentFlags::NONE);
    2774                 :             :     } else {
    2775                 :         138 :         set_return(new Arg::CArrayOut(type_info, length_pos, length_tag,
    2776                 :         276 :                                       length_direction),
    2777                 :             :                    transfer, GjsArgumentFlags::NONE);
    2778                 :             :     }
    2779                 :             : 
    2780                 :         152 :     init_out_array_length_argument(length_arg, flags, length_pos);
    2781                 :         152 : }
    2782                 :             : 
    2783                 :       11935 : void ArgsCache::build_return(const GI::CallableInfo callable,
    2784                 :             :                              bool* inc_counter_out) {
    2785                 :       11935 :     g_assert(inc_counter_out && "forgot out parameter");
    2786                 :             : 
    2787         [ +  + ]:       11935 :     if (!m_has_return) {
    2788                 :        2561 :         *inc_counter_out = false;
    2789                 :        7256 :         return;
    2790                 :             :     }
    2791                 :             : 
    2792                 :        9374 :     GI::StackTypeInfo type_info;
    2793                 :        9374 :     callable.load_return_type(&type_info);
    2794                 :        9374 :     GITransfer transfer = callable.caller_owns();
    2795                 :        9374 :     GITypeTag tag = type_info.tag();
    2796                 :             : 
    2797                 :        9374 :     *inc_counter_out = true;
    2798                 :        9374 :     GjsArgumentFlags flags = GjsArgumentFlags::SKIP_IN;
    2799                 :             : 
    2800         [ +  + ]:        9374 :     if (callable.may_return_null())
    2801                 :         581 :         flags |= GjsArgumentFlags::MAY_BE_NULL;
    2802                 :             : 
    2803   [ +  +  +  +  :        9374 :     switch (tag) {
          +  +  +  +  +  
             +  +  +  +  
                      + ]
    2804                 :        1574 :         case GI_TYPE_TAG_BOOLEAN:
    2805                 :        1574 :             set_return(new Arg::BooleanReturn(), transfer, flags);
    2806                 :        1574 :             return;
    2807                 :             : 
    2808                 :           5 :         case GI_TYPE_TAG_INT8:
    2809                 :           5 :             set_return(new Arg::NumericReturn<int8_t>(), transfer, flags);
    2810                 :           5 :             return;
    2811                 :             : 
    2812                 :           6 :         case GI_TYPE_TAG_INT16:
    2813                 :           6 :             set_return(new Arg::NumericReturn<int16_t>(), transfer, flags);
    2814                 :           6 :             return;
    2815                 :             : 
    2816                 :         130 :         case GI_TYPE_TAG_INT32:
    2817                 :         130 :             set_return(new Arg::NumericReturn<int32_t>(), transfer, flags);
    2818                 :         130 :             return;
    2819                 :             : 
    2820                 :           8 :         case GI_TYPE_TAG_UINT8:
    2821                 :           8 :             set_return(new Arg::NumericReturn<uint8_t>(), transfer, flags);
    2822                 :           8 :             return;
    2823                 :             : 
    2824                 :           5 :         case GI_TYPE_TAG_UINT16:
    2825                 :           5 :             set_return(new Arg::NumericReturn<uint16_t>(), transfer, flags);
    2826                 :           5 :             return;
    2827                 :             : 
    2828                 :         867 :         case GI_TYPE_TAG_UINT32:
    2829                 :         867 :             set_return(new Arg::NumericReturn<uint32_t>(), transfer, flags);
    2830                 :         867 :             return;
    2831                 :             : 
    2832                 :          54 :         case GI_TYPE_TAG_INT64:
    2833                 :          54 :             set_return(new Arg::NumericReturn<int64_t>(), transfer, flags);
    2834                 :          54 :             return;
    2835                 :             : 
    2836                 :         169 :         case GI_TYPE_TAG_UINT64:
    2837                 :         169 :             set_return(new Arg::NumericReturn<uint64_t>(), transfer, flags);
    2838                 :         169 :             return;
    2839                 :             : 
    2840                 :           3 :         case GI_TYPE_TAG_FLOAT:
    2841                 :           3 :             set_return(new Arg::NumericReturn<float>(), transfer, flags);
    2842                 :           3 :             return;
    2843                 :             : 
    2844                 :          30 :         case GI_TYPE_TAG_DOUBLE:
    2845                 :          30 :             set_return(new Arg::NumericReturn<double>(), transfer, flags);
    2846                 :          30 :             return;
    2847                 :             : 
    2848                 :        1318 :         case GI_TYPE_TAG_UTF8:
    2849         [ +  + ]:        1318 :             if (transfer == GI_TRANSFER_NOTHING) {
    2850                 :         228 :                 set_return(new Arg::StringReturn<GI_TRANSFER_NOTHING>(),
    2851                 :             :                            transfer, flags);
    2852                 :         228 :                 return;
    2853                 :             :             } else {
    2854                 :        1090 :                 set_return(new Arg::StringReturn<GI_TRANSFER_EVERYTHING>(),
    2855                 :             :                            transfer, flags);
    2856                 :        1090 :                 return;
    2857                 :             :             }
    2858                 :             : 
    2859                 :         383 :         case GI_TYPE_TAG_ARRAY: {
    2860                 :         383 :             Maybe<unsigned> length_pos = type_info.array_length_index();
    2861         [ +  + ]:         383 :             if (length_pos) {
    2862                 :         152 :                 set_array_return(callable, type_info, flags, *length_pos);
    2863                 :         369 :                 return;
    2864                 :             :             }
    2865                 :             : 
    2866                 :         231 :             GIArrayType array_type = type_info.array_type();
    2867         [ +  + ]:         231 :             if (array_type == GI_ARRAY_TYPE_BYTE_ARRAY) {
    2868                 :           2 :                 set_return(new Arg::ByteArrayReturn(), transfer, flags);
    2869                 :           2 :                 return;
    2870                 :             :             }
    2871                 :             : 
    2872         [ +  + ]:         229 :             if (type_info.element_type().is_basic()) {
    2873         [ +  + ]:         215 :                 if (array_type == GI_ARRAY_TYPE_C) {
    2874         [ +  + ]:         204 :                     if (type_info.is_zero_terminated()) {
    2875                 :         197 :                         set_return(
    2876                 :         197 :                             new Arg::BasicCZeroTerminatedArrayReturn(type_info),
    2877                 :             :                             transfer, flags);
    2878                 :         197 :                         return;
    2879                 :             :                     }
    2880         [ +  - ]:           7 :                     if (type_info.array_fixed_size()) {
    2881                 :           7 :                         set_return(
    2882                 :           7 :                             new Arg::BasicCFixedSizeArrayReturn(type_info),
    2883                 :             :                             transfer, flags);
    2884                 :           7 :                         return;
    2885                 :             :                     }
    2886         [ +  + ]:          11 :                 } else if (array_type == GI_ARRAY_TYPE_ARRAY) {
    2887                 :           6 :                     set_return(new Arg::BasicGArrayReturn(type_info), transfer,
    2888                 :             :                                flags);
    2889                 :           6 :                     return;
    2890         [ +  - ]:           5 :                 } else if (array_type == GI_ARRAY_TYPE_PTR_ARRAY) {
    2891                 :           5 :                     set_return(new Arg::BasicGPtrArrayReturn(type_info),
    2892                 :             :                                transfer, flags);
    2893                 :           5 :                     return;
    2894                 :             :                 }
    2895                 :             :             }
    2896                 :             : 
    2897                 :             :             [[fallthrough]];
    2898                 :             :         }
    2899                 :             : 
    2900                 :             :         default:
    2901                 :        4836 :             break;
    2902                 :             :     }
    2903                 :             : 
    2904         [ +  + ]:        4836 :     if (type_info.is_basic()) {
    2905         [ +  + ]:         125 :         if (transfer == GI_TRANSFER_NOTHING) {
    2906                 :         118 :             set_return(new Arg::BasicTypeReturn(tag), transfer, flags);
    2907                 :             :         } else {
    2908                 :           7 :             set_return(new Arg::BasicTypeTransferableReturn(tag), transfer,
    2909                 :             :                        flags);
    2910                 :             :         }
    2911                 :         125 :         return;
    2912   [ +  +  +  + ]:        4711 :     } else if (tag == GI_TYPE_TAG_GLIST || tag == GI_TYPE_TAG_GSLIST) {
    2913         [ +  + ]:          37 :         if (type_info.element_type().is_basic()) {
    2914                 :          20 :             set_return(new Arg::BasicGListReturn(type_info), transfer, flags);
    2915                 :          20 :             return;
    2916                 :             :         }
    2917         [ +  + ]:        4674 :     } else if (tag == GI_TYPE_TAG_GHASH) {
    2918   [ +  -  +  +  :          51 :         if (type_info.key_type().is_basic() &&
                   +  + ]
    2919   [ +  -  +  - ]:          34 :             type_info.value_type().is_basic()) {
    2920                 :          12 :             set_return(new Arg::BasicGHashReturn(type_info), transfer, flags);
    2921                 :          12 :             return;
    2922                 :             :         }
    2923                 :             :     }
    2924                 :             : 
    2925                 :             :     // in() is ignored for the return value, but skip_in is not (it is used
    2926                 :             :     // in the failure release path)
    2927                 :        4679 :     set_return(new Arg::FallbackReturn(type_info), transfer, flags);
    2928                 :             : }
    2929                 :             : 
    2930                 :             : namespace Arg {
    2931                 :             : 
    2932                 :         252 : Enum::Enum(const GI::EnumInfo info) {
    2933                 :         252 :     int64_t min = std::numeric_limits<int64_t>::max();
    2934                 :         252 :     int64_t max = std::numeric_limits<int64_t>::min();
    2935         [ +  + ]:        3369 :     for (GI::AutoValueInfo value_info : info.values()) {
    2936                 :        3117 :         int64_t value = value_info.value();
    2937                 :             : 
    2938         [ +  + ]:        3117 :         if (value > max)
    2939                 :        3080 :             max = value;
    2940         [ +  + ]:        3117 :         if (value < min)
    2941                 :         265 :             min = value;
    2942                 :        3117 :     }
    2943                 :             : 
    2944                 :             :     // From the docs for g_value_info_get_value(): "This will always be
    2945                 :             :     // representable as a 32-bit signed or unsigned value. The use of gint64 as
    2946                 :             :     // the return type is to allow both."
    2947                 :             :     // We stuff them both into unsigned 32-bit fields, and use a flag to tell
    2948                 :             :     // whether we have to compare them as signed.
    2949                 :         252 :     m_min = static_cast<uint32_t>(min);
    2950                 :         252 :     m_max = static_cast<uint32_t>(max);
    2951                 :             : 
    2952   [ +  +  +  + ]:         252 :     m_unsigned = (min >= 0 && max > std::numeric_limits<int32_t>::max());
    2953                 :         252 : }
    2954                 :             : 
    2955                 :        1530 : Flags::Flags(const GI::FlagsInfo info) {
    2956                 :        1530 :     uint64_t mask = 0;
    2957         [ +  + ]:       17704 :     for (GI::AutoValueInfo value_info : info.values()) {
    2958                 :             :         // From the docs for g_value_info_get_value(): "This will always be
    2959                 :             :         // representable as a 32-bit signed or unsigned value. The use of
    2960                 :             :         // gint64 as the return type is to allow both."
    2961                 :             :         // We stuff both into an unsigned, int-sized field, matching the
    2962                 :             :         // internal representation of flags in GLib (which uses guint).
    2963                 :       16174 :         mask |= static_cast<unsigned>(value_info.value());
    2964                 :       16174 :     }
    2965                 :             : 
    2966                 :        1530 :     m_mask = mask;
    2967                 :        1530 : }
    2968                 :             : 
    2969                 :             : }  // namespace Arg
    2970                 :             : 
    2971                 :             : template <Arg::Kind ArgKind>
    2972                 :        9048 : void ArgsCache::build_interface_in_arg(const Argument::Init& base_args,
    2973                 :             :                                        const GI::BaseInfo interface_info) {
    2974                 :             :     // We do some transfer magic later, so let's ensure we don't mess up.
    2975                 :             :     // Should not happen in practice.
    2976         [ -  + ]:        9048 :     if (G_UNLIKELY(base_args.transfer == GI_TRANSFER_CONTAINER)) {
    2977                 :           0 :         set_argument<ArgKind>(
    2978                 :           0 :             new Arg::NotIntrospectable(INTERFACE_TRANSFER_CONTAINER),
    2979                 :             :             base_args);
    2980                 :        9048 :         return;
    2981                 :             :     }
    2982                 :             : 
    2983   [ +  +  +  + ]:       10578 :     if (auto flags_info = interface_info.as<GI::InfoTag::FLAGS>()) {
    2984                 :        1530 :         set_argument<ArgKind>(new Arg::FlagsIn(*flags_info), base_args);
    2985                 :        1530 :         return;
    2986                 :             :     }
    2987                 :             : 
    2988   [ +  +  +  + ]:        7770 :     if (auto enum_info = interface_info.as<GI::InfoTag::ENUM>()) {
    2989                 :         252 :         set_argument<ArgKind>(new Arg::EnumIn(*enum_info), base_args);
    2990                 :         252 :         return;
    2991                 :             :     }
    2992                 :             : 
    2993                 :        7266 :     auto struct_info = interface_info.as<GI::InfoTag::STRUCT>();
    2994   [ +  +  +  +  :        7266 :     if (struct_info && struct_info->is_foreign()) {
                   +  + ]
    2995                 :             :         if constexpr (ArgKind == Arg::Kind::INSTANCE)
    2996                 :           0 :             set_argument<ArgKind>(
    2997                 :           0 :                 new Arg::ForeignStructInstanceIn(*struct_info), base_args);
    2998                 :             :         else
    2999                 :          35 :             set_argument<ArgKind>(new Arg::ForeignStructIn(*struct_info),
    3000                 :             :                                   base_args);
    3001                 :          35 :         return;
    3002                 :             :     }
    3003                 :             : 
    3004   [ +  -  -  + ]:       14462 :     if (auto reg_info = interface_info.as<GI::InfoTag::REGISTERED_TYPE>()) {
    3005         [ +  + ]:        7231 :         if (reg_info->is_gdk_atom()) {
    3006                 :             :             if constexpr (ArgKind != Arg::Kind::INSTANCE) {
    3007                 :          34 :                 set_argument<ArgKind>(new Arg::GdkAtomIn(), base_args);
    3008                 :          34 :                 return;
    3009                 :             :             }
    3010                 :             :         }
    3011                 :             : 
    3012                 :        7197 :         GType gtype = reg_info->gtype();
    3013                 :             : 
    3014   [ +  +  +  +  :        7512 :         if (struct_info && gtype == G_TYPE_NONE &&
                   +  + ]
    3015         [ +  - ]:         315 :             !struct_info->is_gtype_struct()) {
    3016                 :             :             if constexpr (ArgKind != Arg::Kind::INSTANCE) {
    3017                 :             :                 // This covers cases such as GTypeInstance
    3018                 :         307 :                 set_argument<ArgKind>(new Arg::FallbackInterfaceIn(*reg_info),
    3019                 :             :                                       base_args);
    3020                 :         307 :                 return;
    3021                 :             :             }
    3022                 :             :         }
    3023                 :             : 
    3024                 :             :         // Transfer handling is a bit complex here, because some of our in()
    3025                 :             :         // arguments know not to copy stuff if we don't need to.
    3026                 :             : 
    3027         [ +  + ]:        6890 :         if (gtype == G_TYPE_VALUE) {
    3028                 :             :             if constexpr (ArgKind == Arg::Kind::INSTANCE)
    3029                 :          58 :                 set_argument<ArgKind>(new Arg::BoxedIn(*reg_info), base_args);
    3030         [ +  - ]:          27 :             else if (base_args.transfer == GI_TRANSFER_NOTHING)
    3031                 :          27 :                 set_argument<ArgKind>(new Arg::GValueInTransferNone(*reg_info),
    3032                 :             :                                       base_args);
    3033                 :             :             else
    3034                 :           0 :                 set_argument<ArgKind>(new Arg::GValueIn(*reg_info), base_args);
    3035                 :          85 :             return;
    3036                 :             :         }
    3037                 :             : 
    3038         [ +  + ]:        6805 :         if (gtype == G_TYPE_CLOSURE) {
    3039         [ +  - ]:         725 :             if (base_args.transfer == GI_TRANSFER_NOTHING &&
    3040                 :             :                 ArgKind != Arg::Kind::INSTANCE)
    3041                 :         725 :                 set_argument<ArgKind>(
    3042                 :        1450 :                     new Arg::GClosureInTransferNone(*reg_info), base_args);
    3043                 :             :             else
    3044                 :           0 :                 set_argument<ArgKind>(new Arg::GClosureIn(*reg_info),
    3045                 :             :                                       base_args);
    3046                 :         725 :             return;
    3047                 :             :         }
    3048                 :             : 
    3049         [ +  + ]:        6080 :         if (gtype == G_TYPE_BYTES) {
    3050         [ +  - ]:          78 :             if (base_args.transfer == GI_TRANSFER_NOTHING &&
    3051                 :             :                 ArgKind != Arg::Kind::INSTANCE)
    3052                 :          78 :                 set_argument<ArgKind>(new Arg::GBytesInTransferNone(*reg_info),
    3053                 :             :                                       base_args);
    3054                 :             :             else
    3055                 :           2 :                 set_argument<ArgKind>(new Arg::GBytesIn(*reg_info), base_args);
    3056                 :          80 :             return;
    3057                 :             :         }
    3058                 :             : 
    3059   [ +  +  +  +  :        6000 :         if (g_type_is_a(gtype, G_TYPE_OBJECT)) {
                   +  + ]
    3060                 :        3917 :             set_argument<ArgKind>(new Arg::ObjectIn(*reg_info), base_args);
    3061                 :        3917 :             return;
    3062                 :             :         }
    3063                 :             : 
    3064   [ +  +  -  +  :        2083 :         if (g_type_is_a(gtype, G_TYPE_PARAM)) {
                   +  + ]
    3065                 :             :             if constexpr (ArgKind != Arg::Kind::INSTANCE) {
    3066                 :         147 :                 set_argument<ArgKind>(new Arg::FallbackInterfaceIn(*reg_info),
    3067                 :             :                                       base_args);
    3068                 :         147 :                 return;
    3069                 :             :             }
    3070                 :             :         }
    3071                 :             : 
    3072         [ +  + ]:        1936 :         if (interface_info.is_union()) {
    3073         [ -  + ]:          15 :             if (gtype == G_TYPE_NONE) {
    3074                 :             :                 // Can't handle unions without a GType
    3075                 :           0 :                 set_argument<ArgKind>(
    3076                 :           0 :                     new Arg::NotIntrospectable(UNREGISTERED_UNION), base_args);
    3077                 :           0 :                 return;
    3078                 :             :             }
    3079                 :             : 
    3080                 :          15 :             set_argument<ArgKind>(new Arg::UnionIn(*reg_info), base_args);
    3081                 :          15 :             return;
    3082                 :             :         }
    3083                 :             : 
    3084         [ +  + ]:        1921 :         if (G_TYPE_IS_INSTANTIATABLE(gtype)) {
    3085                 :           4 :             set_argument<ArgKind>(new Arg::FundamentalIn(*reg_info), base_args);
    3086                 :           4 :             return;
    3087                 :             :         }
    3088                 :             : 
    3089   [ +  -  +  +  :        1917 :         if (g_type_is_a(gtype, G_TYPE_INTERFACE)) {
                   +  + ]
    3090                 :           4 :             set_argument<ArgKind>(new Arg::InterfaceIn(*reg_info), base_args);
    3091                 :           4 :             return;
    3092                 :             :         }
    3093                 :             : 
    3094                 :             :         // generic boxed type
    3095         [ +  + ]:        1913 :         if (gtype == G_TYPE_NONE) {
    3096         [ -  + ]:           8 :             if (base_args.transfer != GI_TRANSFER_NOTHING) {
    3097                 :             :                 // Can't transfer ownership of a structure type not
    3098                 :             :                 // registered as a boxed
    3099                 :           0 :                 set_argument<ArgKind>(new Arg::NotIntrospectable(
    3100                 :             :                                           UNREGISTERED_BOXED_WITH_TRANSFER),
    3101                 :             :                                       base_args);
    3102                 :           0 :                 return;
    3103                 :             :             }
    3104                 :             : 
    3105                 :           8 :             set_argument<ArgKind>(new Arg::UnregisteredBoxedIn(*struct_info),
    3106                 :             :                                   base_args);
    3107                 :           8 :             return;
    3108                 :             :         }
    3109                 :        1905 :         set_argument<ArgKind>(new Arg::BoxedIn(*reg_info), base_args);
    3110                 :        1905 :         return;
    3111                 :             :     }
    3112                 :             : 
    3113                 :             :     // Don't know how to handle this interface type (should not happen
    3114                 :             :     // in practice, for typelibs emitted by g-ir-compiler)
    3115                 :           0 :     set_argument<ArgKind>(new Arg::NotIntrospectable(UNSUPPORTED_TYPE),
    3116                 :             :                           base_args);
    3117         [ -  + ]:        7266 : }
    3118                 :             : 
    3119                 :       18044 : void ArgsCache::build_normal_in_arg(uint8_t gi_index,
    3120                 :             :                                     const GI::TypeInfo type_info,
    3121                 :             :                                     const GI::ArgInfo arg,
    3122                 :             :                                     GjsArgumentFlags flags) {
    3123                 :             :     // "Normal" in arguments are those arguments that don't require special
    3124                 :             :     // processing, and don't touch other arguments.
    3125                 :             :     // Main categories are:
    3126                 :             :     // - void*
    3127                 :             :     // - small numbers (fit in 32bit)
    3128                 :             :     // - big numbers (need a double)
    3129                 :             :     // - strings
    3130                 :             :     // - enums/flags (different from numbers in the way they're exposed in GI)
    3131                 :             :     // - objects (GObjects, boxed, unions, etc.)
    3132                 :             :     // - hashes
    3133                 :             :     // - sequences (null-terminated arrays, lists, etc.)
    3134                 :             : 
    3135                 :       18044 :     const char* name = arg.name();
    3136                 :       18044 :     GITransfer transfer = arg.ownership_transfer();
    3137                 :       18044 :     Argument::Init common_args{name, gi_index, transfer, flags};
    3138                 :             : 
    3139   [ +  +  +  +  :       18044 :     switch (type_info.tag()) {
          +  +  +  +  +  
          +  +  +  +  +  
          +  +  +  +  +  
                +  +  - ]
    3140                 :         950 :         case GI_TYPE_TAG_VOID:
    3141                 :         950 :             set_argument(new Arg::NullIn(), common_args);
    3142                 :         950 :             break;
    3143                 :             : 
    3144                 :         400 :         case GI_TYPE_TAG_BOOLEAN:
    3145                 :         400 :             set_argument(new Arg::BooleanIn(), common_args);
    3146                 :         400 :             break;
    3147                 :             : 
    3148                 :         141 :         case GI_TYPE_TAG_INT8:
    3149                 :         141 :             set_argument(new Arg::NumericIn<int8_t>(), common_args);
    3150                 :       10111 :             return;
    3151                 :             : 
    3152                 :          69 :         case GI_TYPE_TAG_INT16:
    3153                 :          69 :             set_argument(new Arg::NumericIn<int16_t>(), common_args);
    3154                 :          69 :             return;
    3155                 :             : 
    3156                 :        1074 :         case GI_TYPE_TAG_INT32:
    3157                 :        1074 :             set_argument(new Arg::NumericIn<int32_t>(), common_args);
    3158                 :        1074 :             return;
    3159                 :             : 
    3160                 :          70 :         case GI_TYPE_TAG_UINT8:
    3161                 :          70 :             set_argument(new Arg::NumericIn<uint8_t>(), common_args);
    3162                 :          70 :             return;
    3163                 :             : 
    3164                 :          74 :         case GI_TYPE_TAG_UINT16:
    3165                 :          74 :             set_argument(new Arg::NumericIn<uint16_t>(), common_args);
    3166                 :          74 :             return;
    3167                 :             : 
    3168                 :        1459 :         case GI_TYPE_TAG_UINT32:
    3169                 :        1459 :             set_argument(new Arg::NumericIn<uint32_t>(), common_args);
    3170                 :        1459 :             return;
    3171                 :             : 
    3172                 :         259 :         case GI_TYPE_TAG_INT64:
    3173                 :         259 :             set_argument(new Arg::NumericIn<int64_t>(), common_args);
    3174                 :         259 :             return;
    3175                 :             : 
    3176                 :         438 :         case GI_TYPE_TAG_UINT64:
    3177                 :         438 :             set_argument(new Arg::NumericIn<uint64_t>(), common_args);
    3178                 :         438 :             return;
    3179                 :             : 
    3180                 :           3 :         case GI_TYPE_TAG_FLOAT:
    3181                 :           3 :             set_argument(new Arg::NumericIn<float>(), common_args);
    3182                 :           3 :             return;
    3183                 :             : 
    3184                 :         235 :         case GI_TYPE_TAG_DOUBLE:
    3185                 :         235 :             set_argument(new Arg::NumericIn<double>(), common_args);
    3186                 :         235 :             return;
    3187                 :             : 
    3188                 :           1 :         case GI_TYPE_TAG_UNICHAR:
    3189                 :           1 :             set_argument(new Arg::UnicharIn(), common_args);
    3190                 :           1 :             break;
    3191                 :             : 
    3192                 :         418 :         case GI_TYPE_TAG_GTYPE:
    3193                 :         418 :             set_argument(new Arg::GTypeIn(), common_args);
    3194                 :         418 :             break;
    3195                 :             : 
    3196                 :         230 :         case GI_TYPE_TAG_FILENAME:
    3197         [ +  - ]:         230 :             if (transfer == GI_TRANSFER_NOTHING)
    3198                 :         230 :                 set_argument(new Arg::FilenameInTransferNone(), common_args);
    3199                 :             :             else
    3200                 :           0 :                 set_argument(new Arg::FilenameIn(), common_args);
    3201                 :         230 :             break;
    3202                 :             : 
    3203                 :        5932 :         case GI_TYPE_TAG_UTF8:
    3204         [ +  + ]:        5932 :             if (transfer == GI_TRANSFER_NOTHING)
    3205                 :        5931 :                 set_argument(new Arg::StringInTransferNone<GI_TYPE_TAG_UTF8>(),
    3206                 :             :                              common_args);
    3207                 :             :             else
    3208                 :           1 :                 set_argument(new Arg::StringIn(), common_args);
    3209                 :        5932 :             break;
    3210                 :             : 
    3211                 :        6028 :         case GI_TYPE_TAG_INTERFACE: {
    3212                 :        6028 :             build_interface_in_arg(common_args, type_info.interface());
    3213                 :        6028 :             return;
    3214                 :             :         }
    3215                 :             : 
    3216                 :          74 :         case GI_TYPE_TAG_ERROR:
    3217                 :          74 :             set_argument(new Arg::ErrorIn(), common_args);
    3218                 :          74 :             return;
    3219                 :             : 
    3220                 :          24 :         case GI_TYPE_TAG_GLIST:
    3221                 :             :         case GI_TYPE_TAG_GSLIST:
    3222         [ +  + ]:          24 :             if (type_info.element_type().is_basic()) {
    3223                 :          14 :                 set_argument(new Arg::BasicGListIn(type_info), common_args);
    3224                 :          14 :                 return;
    3225                 :             :             }
    3226                 :             : 
    3227                 :             :             // Fall back to the generic marshaller
    3228                 :          10 :             set_argument(new Arg::FallbackIn(type_info), common_args);
    3229                 :          10 :             return;
    3230                 :             : 
    3231                 :          12 :         case GI_TYPE_TAG_GHASH:
    3232   [ +  -  +  +  :          36 :             if (type_info.key_type().is_basic() &&
                   +  + ]
    3233   [ +  -  +  - ]:          24 :                 type_info.value_type().is_basic()) {
    3234                 :          11 :                 set_argument(new Arg::BasicGHashIn(type_info), common_args);
    3235                 :          11 :                 return;
    3236                 :             :             }
    3237                 :             : 
    3238                 :             :             // Fall back to the generic marshaller
    3239                 :           1 :             set_argument(new Arg::FallbackIn(type_info), common_args);
    3240                 :           1 :             return;
    3241                 :             : 
    3242                 :         153 :         case GI_TYPE_TAG_ARRAY: {
    3243                 :         153 :             GIArrayType array_type = type_info.array_type();
    3244         [ +  + ]:         153 :             if (array_type == GI_ARRAY_TYPE_BYTE_ARRAY) {
    3245                 :           2 :                 set_argument(new Arg::ByteArrayIn(), common_args);
    3246                 :           2 :                 return;
    3247                 :             :             }
    3248                 :             : 
    3249         [ +  + ]:         151 :             if (type_info.element_type().is_basic()) {
    3250         [ +  + ]:         142 :                 if (array_type == GI_ARRAY_TYPE_ARRAY) {
    3251                 :           6 :                     set_argument(new Arg::BasicGArrayIn(type_info),
    3252                 :             :                                  common_args);
    3253                 :           6 :                     return;
    3254                 :             :                 }
    3255                 :             : 
    3256         [ +  + ]:         136 :                 if (array_type == GI_ARRAY_TYPE_PTR_ARRAY) {
    3257                 :           2 :                     set_argument(new Arg::BasicGPtrArrayIn(type_info),
    3258                 :             :                                  common_args);
    3259                 :           2 :                     return;
    3260                 :             :                 }
    3261                 :             : 
    3262         [ +  - ]:         134 :                 if (array_type == GI_ARRAY_TYPE_C) {
    3263         [ +  + ]:         134 :                     if (type_info.is_zero_terminated()) {
    3264                 :         124 :                         set_argument(
    3265                 :         124 :                             new Arg::BasicCZeroTerminatedArrayIn(type_info),
    3266                 :             :                             common_args);
    3267                 :         124 :                         return;
    3268                 :             :                     }
    3269         [ +  + ]:          10 :                     if (type_info.array_fixed_size()) {
    3270                 :           8 :                         set_argument(new Arg::BasicCFixedSizeArrayIn(type_info),
    3271                 :             :                                      common_args);
    3272                 :           8 :                         return;
    3273                 :             :                     }
    3274                 :             :                 }
    3275                 :             :             }
    3276                 :             : 
    3277         [ +  - ]:          11 :             if (array_type == GI_ARRAY_TYPE_C) {
    3278         [ +  + ]:          11 :                 if (type_info.is_zero_terminated()) {
    3279                 :           6 :                     set_argument(new Arg::ZeroTerminatedArrayIn(type_info),
    3280                 :             :                                  common_args);
    3281                 :           6 :                     return;
    3282                 :             :                 }
    3283         [ +  + ]:           5 :                 if (type_info.array_fixed_size()) {
    3284                 :           3 :                     set_argument(new Arg::FixedSizeArrayIn(type_info),
    3285                 :             :                                  common_args);
    3286                 :           3 :                     return;
    3287                 :             :                 }
    3288                 :             :             }
    3289                 :             :             [[fallthrough]];
    3290                 :             :         }
    3291                 :             : 
    3292                 :             :         default:
    3293                 :             :             // FIXME: Falling back to the generic marshaller
    3294                 :           2 :             set_argument(new Arg::FallbackIn(type_info), common_args);
    3295                 :             :     }
    3296                 :             : }
    3297                 :             : 
    3298                 :         769 : void ArgsCache::build_normal_out_arg(uint8_t gi_index,
    3299                 :             :                                      const GI::TypeInfo type_info,
    3300                 :             :                                      const GI::ArgInfo arg,
    3301                 :             :                                      GjsArgumentFlags flags) {
    3302                 :         769 :     GITransfer transfer = arg.ownership_transfer();
    3303                 :         769 :     Argument::Init common_args{arg.name(), gi_index, transfer, flags};
    3304                 :         769 :     GITypeTag tag = type_info.tag();
    3305                 :             : 
    3306   [ +  +  +  +  :         769 :     switch (tag) {
          +  +  +  +  +  
             +  +  +  + ]
    3307                 :          73 :         case GI_TYPE_TAG_BOOLEAN:
    3308                 :          73 :             set_argument(new Arg::BooleanOut(), common_args);
    3309                 :          73 :             break;
    3310                 :             : 
    3311                 :           7 :         case GI_TYPE_TAG_INT8:
    3312                 :           7 :             set_argument(new Arg::NumericOut<int8_t>(), common_args);
    3313                 :         401 :             return;
    3314                 :             : 
    3315                 :           6 :         case GI_TYPE_TAG_INT16:
    3316                 :           6 :             set_argument(new Arg::NumericOut<int16_t>(), common_args);
    3317                 :           6 :             return;
    3318                 :             : 
    3319                 :          73 :         case GI_TYPE_TAG_INT32:
    3320                 :          73 :             set_argument(new Arg::NumericOut<int32_t>(), common_args);
    3321                 :          73 :             return;
    3322                 :             : 
    3323                 :           2 :         case GI_TYPE_TAG_UINT8:
    3324                 :           2 :             set_argument(new Arg::NumericOut<uint8_t>(), common_args);
    3325                 :           2 :             return;
    3326                 :             : 
    3327                 :           4 :         case GI_TYPE_TAG_UINT16:
    3328                 :           4 :             set_argument(new Arg::NumericOut<uint16_t>(), common_args);
    3329                 :           4 :             return;
    3330                 :             : 
    3331                 :          22 :         case GI_TYPE_TAG_UINT32:
    3332                 :          22 :             set_argument(new Arg::NumericOut<uint32_t>(), common_args);
    3333                 :          22 :             return;
    3334                 :             : 
    3335                 :          19 :         case GI_TYPE_TAG_INT64:
    3336                 :          19 :             set_argument(new Arg::NumericOut<int64_t>(), common_args);
    3337                 :          19 :             return;
    3338                 :             : 
    3339                 :          21 :         case GI_TYPE_TAG_UINT64:
    3340                 :          21 :             set_argument(new Arg::NumericOut<uint64_t>(), common_args);
    3341                 :          21 :             return;
    3342                 :             : 
    3343                 :           9 :         case GI_TYPE_TAG_FLOAT:
    3344                 :           9 :             set_argument(new Arg::NumericOut<float>(), common_args);
    3345                 :           9 :             return;
    3346                 :             : 
    3347                 :          18 :         case GI_TYPE_TAG_DOUBLE:
    3348                 :          18 :             set_argument(new Arg::NumericOut<double>(), common_args);
    3349                 :          18 :             return;
    3350                 :             : 
    3351                 :          90 :         case GI_TYPE_TAG_UTF8:
    3352         [ +  + ]:          90 :             if (transfer == GI_TRANSFER_NOTHING) {
    3353                 :           6 :                 set_argument(new Arg::StringOut<GI_TRANSFER_NOTHING>(),
    3354                 :             :                              common_args);
    3355                 :             :             } else {
    3356                 :          84 :                 set_argument(new Arg::StringOut<GI_TRANSFER_EVERYTHING>(),
    3357                 :             :                              common_args);
    3358                 :             :             }
    3359                 :          90 :             return;
    3360                 :             : 
    3361                 :         498 :         default: {
    3362                 :             :         }
    3363                 :             :     }
    3364                 :             : 
    3365         [ +  + ]:         498 :     if (type_info.is_basic()) {
    3366         [ +  + ]:          77 :         if (transfer == GI_TRANSFER_NOTHING) {
    3367                 :           1 :             set_argument(new Arg::BasicTypeOut(tag), common_args);
    3368                 :             :         } else {
    3369                 :          76 :             set_argument(new Arg::BasicTypeTransferableOut(tag), common_args);
    3370                 :             :         }
    3371                 :          77 :         return;
    3372         [ +  + ]:         421 :     } else if (tag == GI_TYPE_TAG_ARRAY) {
    3373                 :          42 :         GIArrayType array_type = type_info.array_type();
    3374         [ +  + ]:          42 :         if (array_type == GI_ARRAY_TYPE_BYTE_ARRAY) {
    3375                 :           1 :             set_argument(new Arg::ByteArrayOut(), common_args);
    3376                 :           1 :             return;
    3377                 :             :         }
    3378                 :             : 
    3379         [ +  + ]:          41 :         if (type_info.element_type().is_basic()) {
    3380         [ +  + ]:          31 :             if (array_type == GI_ARRAY_TYPE_C) {
    3381         [ +  + ]:          19 :                 if (type_info.is_zero_terminated()) {
    3382                 :          12 :                     set_argument(
    3383                 :          12 :                         new Arg::BasicCZeroTerminatedArrayOut(type_info),
    3384                 :             :                         common_args);
    3385                 :          12 :                     return;
    3386                 :             :                 }
    3387                 :             : 
    3388         [ +  - ]:           7 :                 if (type_info.array_fixed_size()) {
    3389                 :           7 :                     set_argument(new Arg::BasicCFixedSizeArrayOut(type_info),
    3390                 :             :                                  common_args);
    3391                 :           7 :                     return;
    3392                 :             :                 }
    3393         [ +  + ]:          12 :             } else if (array_type == GI_ARRAY_TYPE_ARRAY) {
    3394                 :           6 :                 set_argument(new Arg::BasicGArrayOut(type_info), common_args);
    3395                 :           6 :                 return;
    3396         [ +  - ]:           6 :             } else if (array_type == GI_ARRAY_TYPE_PTR_ARRAY) {
    3397                 :           6 :                 set_argument(new Arg::BasicGPtrArrayOut(type_info),
    3398                 :             :                              common_args);
    3399                 :           6 :                 return;
    3400                 :             :             }
    3401                 :             :         }
    3402                 :             :     }
    3403                 :             : 
    3404   [ +  +  +  + ]:         389 :     if (tag == GI_TYPE_TAG_GLIST || tag == GI_TYPE_TAG_GSLIST) {
    3405         [ +  - ]:          14 :         if (type_info.element_type().is_basic()) {
    3406                 :          14 :             set_argument(new Arg::BasicGListOut(type_info), common_args);
    3407                 :          14 :             return;
    3408                 :             :         }
    3409         [ +  + ]:         375 :     } else if (tag == GI_TYPE_TAG_GHASH) {
    3410   [ +  -  +  -  :          21 :         if (type_info.key_type().is_basic() &&
                   +  - ]
    3411   [ +  -  +  - ]:          14 :             type_info.value_type().is_basic()) {
    3412                 :           7 :             set_argument(new Arg::BasicGHashOut(type_info), common_args);
    3413                 :           7 :             return;
    3414                 :             :         }
    3415         [ +  + ]:         368 :     } else if (tag == GI_TYPE_TAG_ARRAY) {
    3416                 :          10 :         GIArrayType array_type = type_info.array_type();
    3417         [ -  + ]:          10 :         if (array_type == GI_ARRAY_TYPE_BYTE_ARRAY) {
    3418                 :           0 :             set_argument(new Arg::ByteArrayOut(), common_args);
    3419                 :           0 :             return;
    3420                 :             :         }
    3421                 :             : 
    3422         [ -  + ]:          10 :         if (type_info.element_type().is_basic()) {
    3423         [ #  # ]:           0 :             if (array_type == GI_ARRAY_TYPE_C) {
    3424         [ #  # ]:           0 :                 if (type_info.is_zero_terminated()) {
    3425                 :           0 :                     set_argument(
    3426                 :           0 :                         new Arg::BasicCZeroTerminatedArrayOut(type_info),
    3427                 :             :                         common_args);
    3428                 :           0 :                     return;
    3429                 :             :                 }
    3430                 :             : 
    3431         [ #  # ]:           0 :                 if (type_info.array_fixed_size()) {
    3432                 :           0 :                     set_argument(new Arg::BasicCFixedSizeArrayOut(type_info),
    3433                 :             :                                  common_args);
    3434                 :           0 :                     return;
    3435                 :             :                 }
    3436         [ #  # ]:           0 :             } else if (array_type == GI_ARRAY_TYPE_ARRAY) {
    3437                 :           0 :                 set_argument(new Arg::BasicGArrayOut(type_info), common_args);
    3438                 :           0 :                 return;
    3439         [ #  # ]:           0 :             } else if (array_type == GI_ARRAY_TYPE_PTR_ARRAY) {
    3440                 :           0 :                 set_argument(new Arg::BasicGPtrArrayOut(type_info),
    3441                 :             :                              common_args);
    3442                 :           0 :                 return;
    3443                 :             :             }
    3444                 :             :         }
    3445                 :             :     }
    3446                 :             : 
    3447                 :         368 :     set_argument(new Arg::FallbackOut(type_info), common_args);
    3448                 :             : }
    3449                 :             : 
    3450                 :          89 : void ArgsCache::build_normal_inout_arg(uint8_t gi_index,
    3451                 :             :                                        const GI::TypeInfo type_info,
    3452                 :             :                                        const GI::ArgInfo arg,
    3453                 :             :                                        GjsArgumentFlags flags) {
    3454                 :          89 :     GITransfer transfer = arg.ownership_transfer();
    3455                 :          89 :     Argument::Init common_args{arg.name(), gi_index, transfer, flags};
    3456                 :          89 :     GITypeTag tag = type_info.tag();
    3457                 :             : 
    3458   [ +  +  +  +  :          89 :     switch (tag) {
          +  +  +  +  -  
          +  +  +  +  +  
                      + ]
    3459                 :           2 :         case GI_TYPE_TAG_BOOLEAN:
    3460                 :           2 :             set_argument(new Arg::BooleanInOut(), common_args);
    3461                 :           2 :             break;
    3462                 :             : 
    3463                 :           2 :         case GI_TYPE_TAG_INT8:
    3464                 :           2 :             set_argument(new Arg::NumericInOut<int8_t>(), common_args);
    3465                 :          78 :             return;
    3466                 :             : 
    3467                 :           4 :         case GI_TYPE_TAG_INT16:
    3468                 :           4 :             set_argument(new Arg::NumericInOut<int16_t>(), common_args);
    3469                 :           4 :             return;
    3470                 :             : 
    3471                 :          29 :         case GI_TYPE_TAG_INT32:
    3472                 :          29 :             set_argument(new Arg::NumericInOut<int32_t>(), common_args);
    3473                 :          29 :             return;
    3474                 :             : 
    3475                 :           1 :         case GI_TYPE_TAG_UINT8:
    3476                 :           1 :             set_argument(new Arg::NumericInOut<uint8_t>(), common_args);
    3477                 :           1 :             return;
    3478                 :             : 
    3479                 :           2 :         case GI_TYPE_TAG_UINT16:
    3480                 :           2 :             set_argument(new Arg::NumericInOut<uint16_t>(), common_args);
    3481                 :           2 :             return;
    3482                 :             : 
    3483                 :           4 :         case GI_TYPE_TAG_UINT32:
    3484                 :           4 :             set_argument(new Arg::NumericInOut<uint32_t>(), common_args);
    3485                 :           4 :             return;
    3486                 :             : 
    3487                 :           5 :         case GI_TYPE_TAG_INT64:
    3488                 :           5 :             set_argument(new Arg::NumericInOut<int64_t>(), common_args);
    3489                 :           5 :             return;
    3490                 :             : 
    3491                 :           0 :         case GI_TYPE_TAG_UINT64:
    3492                 :           0 :             set_argument(new Arg::NumericInOut<uint64_t>(), common_args);
    3493                 :           0 :             return;
    3494                 :             : 
    3495                 :           4 :         case GI_TYPE_TAG_FLOAT:
    3496                 :           4 :             set_argument(new Arg::NumericInOut<float>(), common_args);
    3497                 :           4 :             return;
    3498                 :             : 
    3499                 :           1 :         case GI_TYPE_TAG_DOUBLE:
    3500                 :           1 :             set_argument(new Arg::NumericInOut<double>(), common_args);
    3501                 :           1 :             return;
    3502                 :             : 
    3503                 :           2 :         case GI_TYPE_TAG_GLIST:
    3504                 :             :         case GI_TYPE_TAG_GSLIST:
    3505         [ +  - ]:           2 :             if (type_info.element_type().is_basic()) {
    3506                 :           2 :                 set_argument(new Arg::BasicGListInOut(type_info), common_args);
    3507                 :           2 :                 return;
    3508                 :             :             }
    3509                 :             : 
    3510                 :           0 :             set_argument(new Arg::FallbackInOut(type_info), common_args);
    3511                 :           0 :             return;
    3512                 :             : 
    3513                 :           1 :         case GI_TYPE_TAG_GHASH:
    3514   [ +  -  +  -  :           3 :             if (type_info.key_type().is_basic() &&
                   +  - ]
    3515   [ +  -  +  - ]:           2 :                 type_info.value_type().is_basic()) {
    3516                 :           1 :                 set_argument(new Arg::BasicGHashInOut(type_info), common_args);
    3517                 :           1 :                 return;
    3518                 :             :             }
    3519                 :             : 
    3520                 :           0 :             set_argument(new Arg::FallbackInOut(type_info), common_args);
    3521                 :           0 :             return;
    3522                 :             : 
    3523                 :          19 :         case GI_TYPE_TAG_ARRAY: {
    3524                 :          19 :             GIArrayType array_type = type_info.array_type();
    3525                 :             : 
    3526         [ +  + ]:          19 :             if (array_type == GI_ARRAY_TYPE_BYTE_ARRAY) {
    3527                 :           1 :                 set_argument(new Arg::ByteArrayInOut(), common_args);
    3528                 :           1 :                 return;
    3529                 :             :             }
    3530                 :             : 
    3531         [ +  + ]:          18 :             if (array_type == GI_ARRAY_TYPE_C) {
    3532         [ +  + ]:          16 :                 if (type_info.is_zero_terminated()) {
    3533         [ +  + ]:           9 :                     if (type_info.element_type().is_basic()) {
    3534                 :           6 :                         set_argument(
    3535                 :           6 :                             new Arg::BasicCZeroTerminatedArrayInOut(type_info),
    3536                 :             :                             common_args);
    3537                 :           6 :                         return;
    3538                 :             :                     }
    3539                 :           3 :                     set_argument(new Arg::ZeroTerminatedArrayInOut(type_info),
    3540                 :             :                                  common_args);
    3541                 :           3 :                     return;
    3542                 :             :                 }
    3543         [ +  - ]:           7 :                 if (type_info.array_fixed_size()) {
    3544         [ +  + ]:           7 :                     if (type_info.element_type().is_basic()) {
    3545                 :           4 :                         set_argument(
    3546                 :           4 :                             new Arg::BasicCFixedSizeArrayInOut(type_info),
    3547                 :             :                             common_args);
    3548                 :           4 :                         return;
    3549                 :             :                     }
    3550                 :           3 :                     set_argument(new Arg::FixedSizeArrayInOut(type_info),
    3551                 :             :                                  common_args);
    3552                 :           3 :                     return;
    3553                 :             :                 }
    3554         [ +  + ]:           2 :             } else if (array_type == GI_ARRAY_TYPE_ARRAY) {
    3555                 :           1 :                 set_argument(new Arg::BasicGArrayInOut(type_info), common_args);
    3556                 :           1 :                 return;
    3557         [ +  - ]:           1 :             } else if (array_type == GI_ARRAY_TYPE_PTR_ARRAY) {
    3558                 :           1 :                 set_argument(new Arg::BasicGPtrArrayInOut(type_info),
    3559                 :             :                              common_args);
    3560                 :           1 :                 return;
    3561                 :             :             }
    3562                 :             : 
    3563                 :           0 :             set_argument(new Arg::FallbackInOut(type_info), common_args);
    3564                 :           0 :             return;
    3565                 :             :         }
    3566                 :             : 
    3567                 :          15 :         default: {
    3568                 :             :         }
    3569                 :             :     }
    3570                 :             : 
    3571         [ +  + ]:          15 :     if (type_info.is_basic()) {
    3572         [ +  + ]:           4 :         if (transfer == GI_TRANSFER_NOTHING) {
    3573                 :           1 :             set_argument(new Arg::BasicTypeInOut(tag), common_args);
    3574                 :             :         } else {
    3575                 :           3 :             set_argument(new Arg::BasicTypeTransferableInOut(tag), common_args);
    3576                 :             :         }
    3577                 :           4 :         return;
    3578                 :             :     }
    3579                 :             : 
    3580                 :          11 :     set_argument(new Arg::FallbackInOut(type_info), common_args);
    3581                 :             : }
    3582                 :             : 
    3583                 :       11935 : void ArgsCache::build_instance(const GI::CallableInfo callable) {
    3584         [ +  + ]:       11935 :     if (!m_is_method)
    3585                 :        8915 :         return;
    3586                 :             : 
    3587                 :        3609 :     Maybe<const GI::BaseInfo> interface_info = callable.container();
    3588                 :        3609 :     g_assert(interface_info && "callable must be a contained type");
    3589                 :             : 
    3590                 :        3609 :     GITransfer transfer = callable.instance_ownership_transfer();
    3591                 :             : 
    3592                 :             :     // These cases could be covered by the generic marshaller, except that
    3593                 :             :     // there's no way to get GITypeInfo for a method's instance parameter.
    3594                 :             :     // Instead, special-case the arguments here that would otherwise go through
    3595                 :             :     // the generic marshaller.
    3596                 :             :     // See: https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/334
    3597                 :        3609 :     auto struct_info = interface_info->as<GI::InfoTag::STRUCT>();
    3598   [ +  +  +  +  :        3609 :     if (struct_info && struct_info->is_gtype_struct()) {
                   +  + ]
    3599                 :         461 :         set_instance(new Arg::GTypeStructInstanceIn(), transfer);
    3600                 :         461 :         return;
    3601                 :             :     }
    3602                 :             : 
    3603         [ +  - ]:        3148 :     if (auto reg_info = interface_info->as<GI::InfoTag::REGISTERED_TYPE>()) {
    3604                 :        3148 :         GType gtype = reg_info->gtype();
    3605                 :             : 
    3606   [ +  +  -  +  :        3148 :         if (g_type_is_a(gtype, G_TYPE_PARAM)) {
                   +  + ]
    3607                 :         128 :             set_instance(new Arg::ParamInstanceIn(), transfer);
    3608                 :         128 :             return;
    3609                 :             :         }
    3610         [ +  + ]:        3148 :     }
    3611                 :             : 
    3612                 :        3020 :     build_interface_in_arg<Arg::Kind::INSTANCE>(
    3613                 :        3020 :         Argument::Init{nullptr, Argument::ABSENT, transfer,
    3614                 :             :                        GjsArgumentFlags::NONE},
    3615                 :             :         *interface_info);
    3616   [ +  +  +  + ]:        4198 : }
    3617                 :             : 
    3618                 :          16 : static constexpr bool type_tag_is_scalar(GITypeTag tag) {
    3619   [ +  -  +  -  :          16 :     return GI_TYPE_TAG_IS_NUMERIC(tag) || tag == GI_TYPE_TAG_BOOLEAN ||
             +  -  -  + ]
    3620                 :          16 :            tag == GI_TYPE_TAG_GTYPE;
    3621                 :             : }
    3622                 :             : 
    3623                 :       21010 : void ArgsCache::build_arg(uint8_t gi_index, GIDirection direction,
    3624                 :             :                           const GI::ArgInfo arg,
    3625                 :             :                           const GI::CallableInfo callable,
    3626                 :             :                           bool* inc_counter_out) {
    3627                 :       21010 :     g_assert(inc_counter_out && "forgot out parameter");
    3628                 :             : 
    3629                 :       21010 :     GI::StackTypeInfo type_info;
    3630                 :       21010 :     arg.load_type(&type_info);
    3631                 :             : 
    3632                 :       21010 :     GjsArgumentFlags flags = GjsArgumentFlags::NONE;
    3633         [ +  + ]:       21010 :     if (arg.may_be_null())
    3634                 :        4156 :         flags |= GjsArgumentFlags::MAY_BE_NULL;
    3635         [ +  + ]:       21010 :     if (arg.caller_allocates())
    3636                 :          19 :         flags |= GjsArgumentFlags::CALLER_ALLOCATES;
    3637                 :             : 
    3638         [ +  + ]:       21010 :     if (direction == GI_DIRECTION_IN)
    3639                 :       20077 :         flags |= GjsArgumentFlags::SKIP_OUT;
    3640         [ +  + ]:         933 :     else if (direction == GI_DIRECTION_OUT)
    3641                 :         819 :         flags |= GjsArgumentFlags::SKIP_IN;
    3642                 :       21010 :     *inc_counter_out = true;
    3643                 :             : 
    3644                 :       21010 :     Argument::Init common_args{arg.name(), gi_index, arg.ownership_transfer(),
    3645                 :       21010 :                                flags};
    3646                 :             : 
    3647                 :       21010 :     GITypeTag type_tag = type_info.tag();
    3648   [ +  +  +  + ]:       21829 :     if (direction == GI_DIRECTION_OUT &&
    3649         [ +  + ]:       21829 :         (flags & GjsArgumentFlags::CALLER_ALLOCATES)) {
    3650                 :          19 :         size_t size = 0;
    3651                 :             : 
    3652         [ +  + ]:          19 :         if (type_tag == GI_TYPE_TAG_ARRAY) {
    3653         [ +  + ]:           3 :             switch (type_info.array_type()) {
    3654                 :           2 :                 case GI_ARRAY_TYPE_C: {
    3655                 :           2 :                     Maybe<size_t> n_elements = type_info.array_fixed_size();
    3656   [ +  -  -  +  :           2 :                     if (!n_elements || *n_elements == 0)
                   -  + ]
    3657                 :           0 :                         break;
    3658                 :             : 
    3659                 :           2 :                     GI::AutoTypeInfo element_type{type_info.element_type()};
    3660                 :           2 :                     size = gjs_type_get_element_size(element_type.tag(),
    3661                 :             :                                                      element_type);
    3662                 :           2 :                     size *= *n_elements;
    3663                 :           2 :                     break;
    3664                 :           2 :                 }
    3665                 :           1 :                 default:
    3666                 :           1 :                     break;
    3667                 :             :             }
    3668   [ +  -  +  +  :          16 :         } else if (!type_tag_is_scalar(type_tag) && !type_info.is_pointer()) {
                   +  + ]
    3669                 :             :             // Scalar out parameters should not be annotated with
    3670                 :             :             // caller-allocates, which is for structured types that need to be
    3671                 :             :             // allocated in order for the function to fill them in.
    3672                 :          14 :             size = gjs_type_get_element_size(type_tag, type_info);
    3673                 :             :         }
    3674                 :             : 
    3675         [ +  + ]:          19 :         if (!size) {
    3676                 :           3 :             set_argument(
    3677                 :           3 :                 new Arg::NotIntrospectable(OUT_CALLER_ALLOCATES_NON_STRUCT),
    3678                 :             :                 common_args);
    3679                 :           3 :             return;
    3680                 :             :         }
    3681                 :             : 
    3682         [ +  + ]:          16 :         if (type_tag == GI_TYPE_TAG_INTERFACE) {
    3683                 :          14 :             GI::AutoBaseInfo interface_info{type_info.interface()};
    3684                 :             :             // FIXME: What if it is not a registered type
    3685                 :             :             GType gtype =
    3686                 :          14 :                 interface_info.as<GI::InfoTag::REGISTERED_TYPE>()->gtype();
    3687   [ +  -  +  +  :          14 :             if (g_type_is_a(gtype, G_TYPE_BOXED)) {
                   +  + ]
    3688                 :          10 :                 set_argument(
    3689                 :          10 :                     new Arg::BoxedCallerAllocatesOut(type_info, size, gtype),
    3690                 :             :                     common_args);
    3691                 :          10 :                 return;
    3692                 :             :             }
    3693         [ +  + ]:          14 :         }
    3694                 :             : 
    3695                 :           6 :         set_argument(new Arg::CallerAllocatesOut(type_info, size), common_args);
    3696                 :           6 :         return;
    3697                 :             :     }
    3698                 :             : 
    3699         [ +  + ]:       20991 :     if (type_tag == GI_TYPE_TAG_INTERFACE) {
    3700                 :        7519 :         GI::AutoBaseInfo interface_info{type_info.interface()};
    3701         [ +  + ]:        7519 :         if (auto callback_info = interface_info.as<GI::InfoTag::CALLBACK>()) {
    3702         [ -  + ]:        1126 :             if (direction != GI_DIRECTION_IN) {
    3703                 :             :                 // Can't do callbacks for out or inout
    3704                 :           0 :                 set_argument(new Arg::NotIntrospectable(CALLBACK_OUT),
    3705                 :             :                              common_args);
    3706                 :           0 :                 return;
    3707                 :             :             }
    3708                 :             : 
    3709   [ +  +  +  + ]:        1191 :             if (strcmp(interface_info.name(), "DestroyNotify") == 0 &&
    3710         [ +  - ]:          65 :                 strcmp(interface_info.ns(), "GLib") == 0) {
    3711                 :             :                 // We don't know (yet) what to do with GDestroyNotify appearing
    3712                 :             :                 // before a callback. If the callback comes later in the
    3713                 :             :                 // argument list, then the invalid argument will be
    3714                 :             :                 // overwritten with the 'skipped' one. If no callback follows,
    3715                 :             :                 // then this is probably an unsupported function, so the
    3716                 :             :                 // function invocation code will check this and throw.
    3717                 :          65 :                 set_argument(
    3718                 :          65 :                     new Arg::NotIntrospectable(DESTROY_NOTIFY_NO_CALLBACK),
    3719                 :             :                     common_args);
    3720                 :          65 :                 *inc_counter_out = false;
    3721                 :             :             } else {
    3722                 :        1061 :                 Maybe<unsigned> destroy_pos = arg.destroy_index();
    3723                 :        1061 :                 Maybe<unsigned> closure_pos = arg.closure_index();
    3724                 :        1061 :                 g_assert(destroy_pos.valueOr(0) <= Argument::MAX_ARGS &&
    3725                 :             :                          "No more than 253 arguments allowed");
    3726                 :        1061 :                 g_assert(closure_pos.valueOr(0) <= Argument::MAX_ARGS &&
    3727                 :             :                          "No more than 253 arguments allowed");
    3728                 :             : 
    3729         [ +  + ]:        1061 :                 if (destroy_pos)
    3730                 :         157 :                     set_skip_all(*destroy_pos);
    3731                 :             : 
    3732         [ +  + ]:        1061 :                 if (closure_pos)
    3733                 :         651 :                     set_skip_all(*closure_pos);
    3734                 :             : 
    3735   [ +  +  +  +  :        1061 :                 if (destroy_pos && !closure_pos) {
                   +  + ]
    3736                 :           1 :                     set_argument(
    3737                 :           1 :                         new Arg::NotIntrospectable(DESTROY_NOTIFY_NO_USER_DATA),
    3738                 :             :                         common_args);
    3739                 :           1 :                     return;
    3740                 :             :                 }
    3741                 :             : 
    3742                 :        1060 :                 set_argument(new Arg::CallbackIn(*callback_info, closure_pos,
    3743                 :        2120 :                                                  destroy_pos, arg.scope()),
    3744                 :             :                              common_args);
    3745                 :             :             }
    3746                 :             : 
    3747                 :        1125 :             return;
    3748         [ +  + ]:        7519 :         }
    3749         [ +  + ]:        7519 :     }
    3750                 :             : 
    3751   [ +  +  +  +  :       21042 :     if (type_tag == GI_TYPE_TAG_ARRAY &&
                   +  + ]
    3752                 :        1177 :         type_info.array_type() == GI_ARRAY_TYPE_C) {
    3753                 :        1151 :         Maybe<unsigned> length_pos = type_info.array_length_index();
    3754                 :             : 
    3755         [ +  + ]:        1151 :         if (length_pos) {
    3756                 :         963 :             Argument* cached_length = argument(*length_pos);
    3757   [ +  +  +  + ]:         967 :             bool skip_length = cached_length && !(cached_length->skip_in() &&
    3758         [ +  + ]:           4 :                                                   cached_length->skip_out());
    3759                 :             : 
    3760                 :         963 :             set_array_argument(callable, gi_index, type_info, direction, arg,
    3761                 :         963 :                                flags, *length_pos);
    3762                 :             : 
    3763   [ +  +  +  +  :         963 :             if (*length_pos < gi_index && skip_length) {
                   +  + ]
    3764                 :             :                 // we already collected length_pos, remove it
    3765                 :         180 :                 *inc_counter_out = false;
    3766                 :             :             }
    3767                 :             : 
    3768                 :         963 :             return;
    3769                 :             :         }
    3770                 :             :     }
    3771                 :             : 
    3772         [ +  + ]:       18902 :     if (direction == GI_DIRECTION_IN)
    3773                 :       18044 :         build_normal_in_arg(gi_index, type_info, arg, flags);
    3774         [ +  + ]:         858 :     else if (direction == GI_DIRECTION_INOUT)
    3775                 :          89 :         build_normal_inout_arg(gi_index, type_info, arg, flags);
    3776                 :             :     else
    3777                 :         769 :         build_normal_out_arg(gi_index, type_info, arg, flags);
    3778                 :             : 
    3779                 :       18902 :     return;
    3780                 :             : }
    3781                 :             : 
    3782                 :             : }  // namespace Gjs
        

Generated by: LCOV version 2.0-1