LCOV - code coverage report
Current view: top level - gi - boxed.cpp (source / functions) Coverage Total Hit
Test: gjs- Code Coverage Lines: 85.7 % 477 409
Test Date: 2025-05-21 00:02:11 Functions: 100.0 % 42 42
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 74.9 % 343 257

             Branch data     Line data    Source code
       1                 :             : /* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; -*- */
       2                 :             : // SPDX-License-Identifier: MIT OR LGPL-2.0-or-later
       3                 :             : // SPDX-FileCopyrightText: 2008 litl, LLC
       4                 :             : 
       5                 :             : #include <config.h>
       6                 :             : 
       7                 :             : #include <stdint.h>
       8                 :             : #include <string.h>  // for memcpy, size_t, strcmp
       9                 :             : 
      10                 :             : #include <algorithm>  // for one_of, any_of
      11                 :             : #include <utility>  // for move, forward
      12                 :             : 
      13                 :             : #include <girepository.h>
      14                 :             : #include <glib-object.h>
      15                 :             : 
      16                 :             : #include <js/CallArgs.h>
      17                 :             : #include <js/Class.h>
      18                 :             : #include <js/ErrorReport.h>  // for JS_ReportOutOfMemory
      19                 :             : #include <js/Exception.h>
      20                 :             : #include <js/GCHashTable.h>  // for GCHashMap
      21                 :             : #include <js/GCVector.h>     // for MutableWrappedPtrOperations
      22                 :             : #include <js/Object.h>       // for SetReservedSlot
      23                 :             : #include <js/PropertyAndElement.h>  // for JS_DefineFunction, JS_Enumerate
      24                 :             : #include <js/String.h>
      25                 :             : #include <js/TracingAPI.h>
      26                 :             : #include <js/TypeDecls.h>
      27                 :             : #include <js/Utility.h>  // for UniqueChars
      28                 :             : #include <js/Value.h>
      29                 :             : #include <js/ValueArray.h>
      30                 :             : #include <jsapi.h>  // for IdVector
      31                 :             : #include <mozilla/HashTable.h>
      32                 :             : #include <mozilla/Span.h>
      33                 :             : 
      34                 :             : #include "gi/arg-inl.h"
      35                 :             : #include "gi/arg.h"
      36                 :             : #include "gi/boxed.h"
      37                 :             : #include "gi/function.h"
      38                 :             : #include "gi/gerror.h"
      39                 :             : #include "gi/repo.h"
      40                 :             : #include "gi/wrapperutils.h"
      41                 :             : #include "gjs/atoms.h"
      42                 :             : #include "gjs/context-private.h"
      43                 :             : #include "gjs/gerror-result.h"
      44                 :             : #include "gjs/jsapi-class.h"
      45                 :             : #include "gjs/jsapi-util.h"
      46                 :             : #include "gjs/macros.h"
      47                 :             : #include "gjs/mem-private.h"
      48                 :             : #include "util/log.h"
      49                 :             : 
      50                 :             : using mozilla::Maybe, mozilla::Some;
      51                 :             : 
      52                 :             : [[nodiscard]] static bool struct_is_simple(const GI::StructInfo& info);
      53                 :             : 
      54                 :       21042 : BoxedInstance::BoxedInstance(BoxedPrototype* prototype, JS::HandleObject obj)
      55                 :             :     : GIWrapperInstance(prototype, obj),
      56                 :       21042 :       m_allocated_directly(false),
      57                 :       21042 :       m_owning_ptr(false) {
      58                 :       21042 :     GJS_INC_COUNTER(boxed_instance);
      59                 :       21042 : }
      60                 :             : 
      61                 :             : // See GIWrapperBase::resolve().
      62                 :        6550 : bool BoxedPrototype::resolve_impl(JSContext* cx, JS::HandleObject obj,
      63                 :             :                                   JS::HandleId id, bool* resolved) {
      64                 :        6550 :     JS::UniqueChars prop_name;
      65         [ -  + ]:        6550 :     if (!gjs_get_string_id(cx, id, &prop_name))
      66                 :           0 :         return false;
      67         [ +  + ]:        6550 :     if (!prop_name) {
      68                 :         411 :         *resolved = false;
      69                 :         411 :         return true;  // not resolved, but no error
      70                 :             :     }
      71                 :             : 
      72                 :             :     // Look for methods and other class properties
      73                 :        6139 :     Maybe<GI::AutoFunctionInfo> method_info{info().method(prop_name.get())};
      74         [ +  + ]:        6139 :     if (!method_info) {
      75                 :        5283 :         *resolved = false;
      76                 :        5283 :         return true;
      77                 :             :     }
      78                 :         856 :     method_info->log_usage();
      79                 :             : 
      80         [ +  - ]:         856 :     if (method_info->is_method()) {
      81                 :        1712 :         gjs_debug(GJS_DEBUG_GBOXED, "Defining method %s in prototype for %s",
      82                 :        2568 :                   method_info->name(), format_name().c_str());
      83                 :             : 
      84                 :             :         /* obj is the Boxed prototype */
      85         [ -  + ]:         856 :         if (!gjs_define_function(cx, obj, gtype(), *method_info))
      86                 :           0 :             return false;
      87                 :             : 
      88                 :         856 :         *resolved = true;
      89                 :             :     } else {
      90                 :           0 :         *resolved = false;
      91                 :             :     }
      92                 :             : 
      93                 :         856 :     return true;
      94                 :        6550 : }
      95                 :             : 
      96                 :             : // See GIWrapperBase::new_enumerate().
      97                 :           3 : bool BoxedPrototype::new_enumerate_impl(JSContext* cx, JS::HandleObject,
      98                 :             :                                         JS::MutableHandleIdVector properties,
      99                 :             :                                         bool only_enumerable [[maybe_unused]]) {
     100         [ +  + ]:          36 :     for (GI::AutoFunctionInfo meth_info : info().methods()) {
     101         [ +  - ]:          33 :         if (meth_info.is_method()) {
     102                 :          33 :             jsid id = gjs_intern_string_to_id(cx, meth_info.name());
     103         [ -  + ]:          33 :             if (id.isVoid())
     104                 :           0 :                 return false;
     105         [ -  + ]:          33 :             if (!properties.append(id)) {
     106                 :           0 :                 JS_ReportOutOfMemory(cx);
     107                 :           0 :                 return false;
     108                 :             :             }
     109                 :             :         }
     110         [ +  - ]:          33 :     }
     111                 :             : 
     112                 :           3 :     return true;
     113                 :             : }
     114                 :             : 
     115                 :             : /*
     116                 :             :  * BoxedBase::get_copy_source():
     117                 :             :  *
     118                 :             :  * Check to see if JS::Value passed in is another Boxed instance object of the
     119                 :             :  * same type, and if so, retrieve the BoxedInstance private structure for it.
     120                 :             :  * This function does not throw any JS exceptions.
     121                 :             :  */
     122                 :        1008 : BoxedBase* BoxedBase::get_copy_source(JSContext* context,
     123                 :             :                                       JS::Value value) const {
     124         [ +  + ]:        1008 :     if (!value.isObject())
     125                 :         902 :         return nullptr;
     126                 :             : 
     127                 :         106 :     JS::RootedObject object(context, &value.toObject());
     128                 :         106 :     BoxedBase* source_priv = BoxedBase::for_js(context, object);
     129   [ +  +  +  +  :         106 :     if (!source_priv || info() != source_priv->info())
                   +  + ]
     130                 :          94 :         return nullptr;
     131                 :             : 
     132                 :          12 :     return source_priv;
     133                 :         106 : }
     134                 :             : 
     135                 :             : /*
     136                 :             :  * BoxedInstance::allocate_directly:
     137                 :             :  *
     138                 :             :  * Allocate a boxed object of the correct size, set all the bytes to 0, and set
     139                 :             :  * m_ptr to point to it. This is used when constructing a boxed object that can
     140                 :             :  * be allocated directly (i.e., does not need to be created by a constructor
     141                 :             :  * function.)
     142                 :             :  */
     143                 :         429 : void BoxedInstance::allocate_directly(void) {
     144                 :         429 :     g_assert(get_prototype()->can_allocate_directly());
     145                 :             : 
     146                 :         429 :     own_ptr(g_malloc0(info().size()));
     147                 :         429 :     m_allocated_directly = true;
     148                 :             : 
     149                 :         429 :     debug_lifecycle("Boxed pointer directly allocated");
     150                 :         429 : }
     151                 :             : 
     152                 :             : // When initializing a boxed object from a hash of properties, we don't want to
     153                 :             : // do n O(n) lookups, so put put the fields into a hash table and store it on
     154                 :             : // proto->priv for fast lookup.
     155                 :          15 : std::unique_ptr<BoxedPrototype::FieldMap> BoxedPrototype::create_field_map(
     156                 :             :     JSContext* cx, const GI::StructInfo struct_info) {
     157                 :          15 :     auto result = std::make_unique<BoxedPrototype::FieldMap>();
     158                 :          15 :     GI::StructInfo::FieldsIterator fields = struct_info.fields();
     159         [ -  + ]:          15 :     if (!result->reserve(fields.size())) {
     160                 :           0 :         JS_ReportOutOfMemory(cx);
     161                 :           0 :         return nullptr;
     162                 :             :     }
     163                 :             : 
     164         [ +  + ]:          57 :     for (GI::AutoFieldInfo field_info : fields) {
     165                 :             :         // We get the string as a jsid later, which is interned. We intern the
     166                 :             :         // string here as well, so it will be the same string pointer
     167                 :          42 :         JSString* atom = JS_AtomizeAndPinString(cx, field_info.name());
     168                 :             : 
     169                 :          42 :         result->putNewInfallible(atom, std::move(field_info));
     170                 :          42 :     }
     171                 :             : 
     172                 :          15 :     return result;
     173                 :          15 : }
     174                 :             : 
     175                 :             : /*
     176                 :             :  * BoxedPrototype::ensure_field_map:
     177                 :             :  *
     178                 :             :  * BoxedPrototype keeps a cache of field names to introspection info.
     179                 :             :  * We only create the field cache the first time it is needed. An alternative
     180                 :             :  * would be to create it when the prototype is created, in BoxedPrototype::init.
     181                 :             :  */
     182                 :         117 : bool BoxedPrototype::ensure_field_map(JSContext* cx) {
     183         [ +  + ]:         117 :     if (!m_field_map)
     184                 :          15 :         m_field_map = create_field_map(cx, info());
     185                 :         117 :     return !!m_field_map;
     186                 :             : }
     187                 :             : 
     188                 :             : /*
     189                 :             :  * BoxedPrototype::lookup_field:
     190                 :             :  *
     191                 :             :  * Look up the introspection info corresponding to the field name @prop_name,
     192                 :             :  * creating the field cache if necessary.
     193                 :             :  */
     194                 :         117 : Maybe<const GI::FieldInfo> BoxedPrototype::lookup_field(JSContext* cx,
     195                 :             :                                                         JSString* prop_name) {
     196         [ -  + ]:         117 :     if (!ensure_field_map(cx))
     197                 :           0 :         return {};
     198                 :             : 
     199                 :         117 :     auto entry = m_field_map->lookup(prop_name);
     200         [ +  + ]:         117 :     if (!entry) {
     201                 :           4 :         gjs_throw(cx, "No field %s on boxed type %s",
     202                 :           4 :                   gjs_debug_string(prop_name).c_str(), name());
     203                 :           2 :         return {};
     204                 :             :     }
     205                 :             : 
     206                 :         115 :     return Some(entry->value());
     207                 :             : }
     208                 :             : 
     209                 :             : /* Initialize a newly created Boxed from an object that is a "hash" of
     210                 :             :  * properties to set as fields of the object. We don't require that every field
     211                 :             :  * of the object be set.
     212                 :             :  */
     213                 :          79 : bool BoxedInstance::init_from_props(JSContext* context, JS::Value props_value) {
     214                 :             :     size_t ix, length;
     215                 :             : 
     216         [ -  + ]:          79 :     if (!props_value.isObject()) {
     217                 :           0 :         gjs_throw(context, "argument should be a hash with fields to set");
     218                 :           0 :         return false;
     219                 :             :     }
     220                 :             : 
     221                 :          79 :     JS::RootedObject props(context, &props_value.toObject());
     222                 :          79 :     JS::Rooted<JS::IdVector> ids(context, context);
     223         [ -  + ]:          79 :     if (!JS_Enumerate(context, props, &ids)) {
     224                 :           0 :         gjs_throw(context, "Failed to enumerate fields hash");
     225                 :           0 :         return false;
     226                 :             :     }
     227                 :             : 
     228                 :          79 :     JS::RootedValue value(context);
     229         [ +  + ]:         194 :     for (ix = 0, length = ids.length(); ix < length; ix++) {
     230         [ -  + ]:         117 :         if (!ids[ix].isString()) {
     231                 :           0 :             gjs_throw(context, "Fields hash contained a non-string field");
     232                 :           2 :             return false;
     233                 :             :         }
     234                 :             : 
     235                 :             :         Maybe<const GI::FieldInfo> field_info =
     236                 :         117 :             get_prototype()->lookup_field(context, ids[ix].toString());
     237         [ +  + ]:         117 :         if (!field_info)
     238                 :           2 :             return false;
     239                 :             : 
     240                 :             :         /* ids[ix] is reachable because props is rooted, but require_property
     241                 :             :          * doesn't know that */
     242                 :         230 :         if (!gjs_object_require_property(context, props, "property list",
     243         [ -  + ]:         230 :                                          JS::HandleId::fromMarkedLocation(ids[ix].address()),
     244                 :             :                                          &value))
     245                 :           0 :             return false;
     246                 :             : 
     247         [ -  + ]:         115 :         if (!field_setter_impl(context, *field_info, value))
     248                 :           0 :             return false;
     249         [ +  + ]:         117 :     }
     250                 :             : 
     251                 :          77 :     return true;
     252                 :          79 : }
     253                 :             : 
     254                 :             : GJS_JSAPI_RETURN_CONVENTION
     255                 :        1493 : static bool boxed_invoke_constructor(JSContext* context, JS::HandleObject obj,
     256                 :             :                                      JS::HandleId constructor_name,
     257                 :             :                                      const JS::CallArgs& args) {
     258                 :        1493 :     GjsContextPrivate* gjs = GjsContextPrivate::from_cx(context);
     259                 :        1493 :     JS::RootedObject js_constructor(context);
     260                 :             : 
     261         [ -  + ]:        2986 :     if (!gjs_object_require_property(
     262                 :        1493 :             context, obj, nullptr, gjs->atoms().constructor(), &js_constructor))
     263                 :           0 :         return false;
     264                 :             : 
     265                 :        1493 :     JS::RootedValue js_constructor_func(context);
     266         [ -  + ]:        1493 :     if (!gjs_object_require_property(context, js_constructor, NULL,
     267                 :             :                                      constructor_name, &js_constructor_func))
     268                 :           0 :         return false;
     269                 :             : 
     270                 :        1493 :     return gjs->call_function(nullptr, js_constructor_func, args, args.rval());
     271                 :        1493 : }
     272                 :             : 
     273                 :             : /*
     274                 :             :  * BoxedInstance::copy_boxed:
     275                 :             :  *
     276                 :             :  * Allocate a new boxed pointer using g_boxed_copy(), either from a raw boxed
     277                 :             :  * pointer or another BoxedInstance.
     278                 :             :  */
     279                 :       15671 : void BoxedInstance::copy_boxed(void* boxed_ptr) {
     280                 :       15671 :     own_ptr(g_boxed_copy(gtype(), boxed_ptr));
     281                 :       15671 :     debug_lifecycle("Boxed pointer created with g_boxed_copy()");
     282                 :       15671 : }
     283                 :             : 
     284                 :          11 : void BoxedInstance::copy_boxed(BoxedInstance* source) {
     285                 :          11 :     copy_boxed(source->ptr());
     286                 :          11 : }
     287                 :             : 
     288                 :             : /*
     289                 :             :  * BoxedInstance::copy_memory:
     290                 :             :  *
     291                 :             :  * Allocate a new boxed pointer by copying the contents of another boxed pointer
     292                 :             :  * or another BoxedInstance.
     293                 :             :  */
     294                 :          26 : void BoxedInstance::copy_memory(void* boxed_ptr) {
     295                 :          26 :     allocate_directly();
     296                 :          26 :     memcpy(m_ptr, boxed_ptr, info().size());
     297                 :          26 : }
     298                 :             : 
     299                 :           1 : void BoxedInstance::copy_memory(BoxedInstance* source) {
     300                 :           1 :     copy_memory(source->ptr());
     301                 :           1 : }
     302                 :             : 
     303                 :             : // See GIWrapperBase::constructor().
     304                 :        1995 : bool BoxedInstance::constructor_impl(JSContext* context, JS::HandleObject obj,
     305                 :             :                                      const JS::CallArgs& args) {
     306                 :             :     // Short-circuit copy-construction in the case where we can use copy_boxed()
     307                 :             :     // or copy_memory()
     308                 :             :     BoxedBase* source_priv;
     309   [ +  +  +  + ]:        3000 :     if (args.length() == 1 &&
     310         [ +  + ]:        3000 :         (source_priv = get_copy_source(context, args[0]))) {
     311         [ -  + ]:          12 :         if (!source_priv->check_is_instance(context, "construct boxed object"))
     312                 :           0 :             return false;
     313                 :             : 
     314   [ +  -  +  +  :          12 :         if (g_type_is_a(gtype(), G_TYPE_BOXED)) {
                   +  + ]
     315                 :          11 :             copy_boxed(source_priv->to_instance());
     316                 :          11 :             return true;
     317         [ +  - ]:           1 :         } else if (get_prototype()->can_allocate_directly()) {
     318                 :           1 :             copy_memory(source_priv->to_instance());
     319                 :           1 :             return true;
     320                 :             :         }
     321                 :             :     }
     322                 :             : 
     323         [ +  + ]:        1983 :     if (gtype() == G_TYPE_VARIANT) {
     324                 :             :         /* Short-circuit construction for GVariants by calling into the JS packing
     325                 :             :            function */
     326                 :         485 :         const GjsAtoms& atoms = GjsContextPrivate::atoms(context);
     327         [ +  + ]:         485 :         if (!boxed_invoke_constructor(context, obj, atoms.new_internal(), args))
     328                 :           2 :             return false;
     329                 :             : 
     330                 :             :         // The return value of GLib.Variant.new_internal() gets its own
     331                 :             :         // BoxedInstance, and the one we're setting up in this constructor is
     332                 :             :         // discarded.
     333                 :         483 :         debug_lifecycle(
     334                 :             :             "Boxed construction delegated to GVariant constructor, "
     335                 :             :             "boxed object discarded");
     336                 :             : 
     337                 :         483 :         return true;
     338                 :             :     }
     339                 :             : 
     340                 :        1498 :     BoxedPrototype* proto = get_prototype();
     341                 :             : 
     342                 :             :     // If the structure is registered as a boxed, we can create a new instance
     343                 :             :     // by looking for a zero-args constructor and calling it.
     344                 :             :     // Constructors don't really make sense for non-boxed types, since there is
     345                 :             :     // no memory management for the return value, and zero_args_constructor and
     346                 :             :     // default_constructor are always -1 for them.
     347                 :             :     //
     348                 :             :     // For backward compatibility, we choose the zero args constructor if one
     349                 :             :     // exists, otherwise we malloc the correct amount of space if possible;
     350                 :             :     // finally, we fallback on the default constructor.
     351         [ +  + ]:        1498 :     if (proto->has_zero_args_constructor()) {
     352                 :          85 :         GI::AutoFunctionInfo func_info{proto->zero_args_constructor_info()};
     353                 :             : 
     354                 :             :         GIArgument rval_arg;
     355                 :          85 :         Gjs::GErrorResult<> result = func_info.invoke({}, {}, &rval_arg);
     356         [ -  + ]:          85 :         if (result.isErr()) {
     357                 :           0 :             gjs_throw(context, "Failed to invoke boxed constructor: %s",
     358                 :           0 :                       result.inspectErr()->message);
     359                 :           0 :             return false;
     360                 :             :         }
     361                 :             : 
     362                 :          85 :         own_ptr(gjs_arg_steal<void*>(&rval_arg));
     363                 :             : 
     364                 :          85 :         debug_lifecycle("Boxed pointer created from zero-args constructor");
     365                 :             : 
     366   [ +  -  +  -  :        1498 :     } else if (proto->can_allocate_directly_without_pointers()) {
                   +  + ]
     367                 :         403 :         allocate_directly();
     368         [ +  + ]:        1010 :     } else if (proto->has_default_constructor()) {
     369                 :             :         /* for simplicity, we simply delegate all the work to the actual JS
     370                 :             :          * constructor function (which we retrieve from the JS constructor,
     371                 :             :          * that is, Namespace.BoxedType, or object.constructor, given that
     372                 :             :          * object was created with the right prototype. */
     373         [ +  + ]:        1008 :         if (!boxed_invoke_constructor(context, obj,
     374                 :             :                                       proto->default_constructor_name(), args))
     375                 :           1 :             return false;
     376                 :             : 
     377                 :             :         // Define the expected Error properties
     378         [ +  + ]:        1007 :         if (gtype() == G_TYPE_ERROR) {
     379                 :           3 :             JS::RootedObject gerror(context, &args.rval().toObject());
     380         [ -  + ]:           3 :             if (!gjs_define_error_properties(context, gerror))
     381                 :           0 :                 return false;
     382         [ +  - ]:           3 :         }
     383                 :             : 
     384                 :             :         // The return value of the JS constructor gets its own BoxedInstance,
     385                 :             :         // and this one is discarded.
     386                 :        1007 :         debug_lifecycle(
     387                 :             :             "Boxed construction delegated to JS constructor, "
     388                 :             :             "boxed object discarded");
     389                 :             : 
     390                 :        1007 :         return true;
     391         [ -  + ]:           2 :     } else if (proto->can_allocate_directly()) {
     392                 :           0 :         allocate_directly();
     393                 :             :     } else {
     394                 :           2 :         gjs_throw(context,
     395                 :             :                   "Unable to construct struct type %s since it has no default "
     396                 :             :                   "constructor and cannot be allocated directly",
     397                 :             :                   name());
     398                 :           2 :         return false;
     399                 :             :     }
     400                 :             : 
     401                 :             :     /* If we reach this code, we need to init from a map of fields */
     402                 :             : 
     403         [ +  + ]:         488 :     if (args.length() == 0)
     404                 :         409 :         return true;
     405                 :             : 
     406         [ -  + ]:          79 :     if (args.length() > 1) {
     407                 :           0 :         gjs_throw(context,
     408                 :             :                   "Constructor with multiple arguments not supported for %s",
     409                 :             :                   name());
     410                 :           0 :         return false;
     411                 :             :     }
     412                 :             : 
     413                 :          79 :     return init_from_props(context, args[0]);
     414                 :             : }
     415                 :             : 
     416                 :       21039 : BoxedInstance::~BoxedInstance() {
     417         [ +  + ]:       21039 :     if (m_owning_ptr) {
     418         [ +  + ]:       19515 :         if (m_allocated_directly) {
     419         [ +  + ]:         429 :             if (gtype() == G_TYPE_VALUE)
     420                 :         337 :                 g_value_unset(m_ptr.as<GValue>());
     421                 :         429 :             g_free(m_ptr.release());
     422                 :             :         } else {
     423   [ +  -  +  +  :       19086 :             if (g_type_is_a(gtype(), G_TYPE_BOXED))
                   +  + ]
     424                 :       15754 :                 g_boxed_free(gtype(), m_ptr.release());
     425   [ -  +  -  -  :        3332 :             else if (g_type_is_a(gtype(), G_TYPE_VARIANT))
                   +  - ]
     426                 :        3332 :                 g_variant_unref(static_cast<GVariant*>(m_ptr.release()));
     427                 :             :             else
     428                 :             :                 g_assert_not_reached ();
     429                 :             :         }
     430                 :             :     }
     431                 :             : 
     432                 :       21039 :     GJS_DEC_COUNTER(boxed_instance);
     433                 :       21039 : }
     434                 :             : 
     435                 :         861 : BoxedPrototype::~BoxedPrototype(void) {
     436                 :         861 :     GJS_DEC_COUNTER(boxed_prototype);
     437                 :         861 : }
     438                 :             : 
     439                 :             : /*
     440                 :             :  * BoxedBase::get_field_info:
     441                 :             :  *
     442                 :             :  * Does the same thing as g_struct_info_get_field(), but throws a JS exception
     443                 :             :  * if there is no such field.
     444                 :             :  */
     445                 :        2097 : Maybe<GI::AutoFieldInfo> BoxedBase::get_field_info(JSContext* cx,
     446                 :             :                                                    uint32_t id) const {
     447                 :        2097 :     Maybe<GI::AutoFieldInfo> field_info = info().fields()[id];
     448         [ -  + ]:        2097 :     if (!field_info)
     449                 :           0 :         gjs_throw(cx, "No field %d on boxed type %s", id, name());
     450                 :             : 
     451                 :        2097 :     return field_info;
     452                 :             : }
     453                 :             : 
     454                 :             : /*
     455                 :             :  * BoxedInstance::get_nested_interface_object:
     456                 :             :  * @parent_obj: the BoxedInstance JS object that owns `this`
     457                 :             :  * @field_info: introspection info for the field of the parent boxed type that
     458                 :             :  *   is another boxed type
     459                 :             :  * @interface_info: introspection info for the nested boxed type
     460                 :             :  * @value: return location for a new BoxedInstance JS object
     461                 :             :  *
     462                 :             :  * Some boxed types have a field that consists of another boxed type. We want to
     463                 :             :  * be able to expose these nested boxed types without copying them, because
     464                 :             :  * changing fields of the nested boxed struct should affect the enclosing boxed
     465                 :             :  * struct.
     466                 :             :  *
     467                 :             :  * This method creates a new BoxedInstance and JS object for a nested boxed
     468                 :             :  * struct. Since both the nested JS object and the parent boxed's JS object
     469                 :             :  * refer to the same memory, the parent JS object will be prevented from being
     470                 :             :  * garbage collected while the nested JS object is active.
     471                 :             :  */
     472                 :          16 : bool BoxedInstance::get_nested_interface_object(
     473                 :             :     JSContext* context, JSObject* parent_obj, const GI::FieldInfo field_info,
     474                 :             :     const GI::StructInfo struct_info, JS::MutableHandleValue value) const {
     475         [ -  + ]:          16 :     if (!struct_is_simple(struct_info)) {
     476                 :           0 :         gjs_throw(context, "Reading field %s.%s is not supported",
     477                 :           0 :                   format_name().c_str(), field_info.name());
     478                 :             : 
     479                 :           0 :         return false;
     480                 :             :     }
     481                 :             : 
     482                 :             :     JS::RootedObject obj{
     483                 :          16 :         context, gjs_new_object_with_generic_prototype(context, struct_info)};
     484         [ -  + ]:          16 :     if (!obj)
     485                 :           0 :         return false;
     486                 :             : 
     487                 :          16 :     BoxedInstance* priv = BoxedInstance::new_for_js_object(context, obj);
     488                 :             : 
     489                 :             :     /* A structure nested inside a parent object; doesn't have an independent allocation */
     490                 :          16 :     priv->share_ptr(raw_ptr() + field_info.offset());
     491                 :          16 :     priv->debug_lifecycle(
     492                 :             :         "Boxed pointer created, pointing inside memory owned by parent");
     493                 :             : 
     494                 :             :     /* We never actually read the reserved slot, but we put the parent object
     495                 :             :      * into it to hold onto the parent object.
     496                 :             :      */
     497                 :          16 :     JS::SetReservedSlot(obj, BoxedInstance::PARENT_OBJECT,
     498                 :          16 :                         JS::ObjectValue(*parent_obj));
     499                 :             : 
     500                 :          16 :     value.setObject(*obj);
     501                 :          16 :     return true;
     502                 :          16 : }
     503                 :             : 
     504                 :             : /*
     505                 :             :  * BoxedBase::field_getter:
     506                 :             :  *
     507                 :             :  * JSNative property getter that is called when accessing a field defined on a
     508                 :             :  * boxed type. Delegates to BoxedInstance::field_getter_impl() if the minimal
     509                 :             :  * conditions have been met.
     510                 :             :  */
     511                 :        2011 : bool BoxedBase::field_getter(JSContext* context, unsigned argc, JS::Value* vp) {
     512   [ -  +  -  + ]:        2011 :     GJS_CHECK_WRAPPER_PRIV(context, argc, vp, args, obj, BoxedBase, priv);
     513         [ -  + ]:        2011 :     if (!priv->check_is_instance(context, "get a field"))
     514                 :           0 :         return false;
     515                 :             : 
     516                 :        2011 :     uint32_t field_ix = gjs_dynamic_property_private_slot(&args.callee())
     517                 :        2011 :         .toPrivateUint32();
     518                 :             :     Maybe<GI::AutoFieldInfo> field_info{
     519                 :        2011 :         priv->get_field_info(context, field_ix)};
     520         [ -  + ]:        2011 :     if (!field_info)
     521                 :           0 :         return false;
     522                 :             : 
     523                 :        6033 :     return priv->to_instance()->field_getter_impl(
     524                 :        4022 :         context, obj, field_info.ref(), args.rval());
     525                 :        2011 : }
     526                 :             : 
     527                 :             : // See BoxedBase::field_getter().
     528                 :        2011 : bool BoxedInstance::field_getter_impl(JSContext* cx, JSObject* obj,
     529                 :             :                                       const GI::FieldInfo field_info,
     530                 :             :                                       JS::MutableHandleValue rval) const {
     531                 :        2011 :     GI::AutoTypeInfo type_info{field_info.type_info()};
     532                 :             : 
     533   [ +  +  +  +  :        2011 :     if (!type_info.is_pointer() && type_info.tag() == GI_TYPE_TAG_INTERFACE) {
                   +  + ]
     534                 :          55 :         GI::AutoBaseInfo interface{type_info.interface()};
     535         [ +  + ]:          55 :         if (auto struct_info = interface.as<GI::InfoTag::STRUCT>()) {
     536                 :          16 :             return get_nested_interface_object(cx, obj, field_info,
     537                 :          32 :                                                struct_info.value(), rval);
     538         [ +  + ]:          55 :         }
     539         [ +  + ]:          55 :     }
     540                 :             : 
     541                 :             :     GIArgument arg;
     542         [ -  + ]:        1995 :     if (field_info.read(m_ptr, &arg).isErr()) {
     543                 :           0 :         gjs_throw(cx, "Reading field %s.%s is not supported",
     544                 :           0 :                   format_name().c_str(), field_info.name());
     545                 :           0 :         return false;
     546                 :             :     }
     547                 :             : 
     548   [ +  +  +  + ]:        2415 :     if (type_info.tag() == GI_TYPE_TAG_ARRAY &&
     549         [ +  + ]:        2415 :         type_info.array_length_index()) {
     550                 :           2 :         unsigned length_field_ix = type_info.array_length_index().value();
     551                 :             :         Maybe<GI::AutoFieldInfo> length_field_info{
     552                 :           2 :             get_field_info(cx, length_field_ix)};
     553         [ -  + ]:           2 :         if (!length_field_info) {
     554                 :           0 :             gjs_throw(cx, "Reading field %s.%s is not supported",
     555                 :           0 :                       format_name().c_str(), field_info.name());
     556                 :           0 :             return false;
     557                 :             :         }
     558                 :             : 
     559                 :             :         GIArgument length_arg;
     560         [ -  + ]:           2 :         if (length_field_info->read(m_ptr, &length_arg).isErr()) {
     561                 :           0 :             gjs_throw(cx, "Reading field %s.%s is not supported",
     562                 :           0 :                       format_name().c_str(), length_field_info->name());
     563                 :           0 :             return false;
     564                 :             :         }
     565                 :             : 
     566                 :           2 :         size_t length = gjs_gi_argument_get_array_length(
     567                 :           4 :             length_field_info->type_info().tag(), &length_arg);
     568                 :           2 :         return gjs_value_from_explicit_array(cx, rval, type_info, &arg, length);
     569                 :           2 :     }
     570                 :             : 
     571                 :        3986 :     return gjs_value_from_gi_argument(cx, rval, type_info, GJS_ARGUMENT_FIELD,
     572                 :        1993 :                                       GI_TRANSFER_EVERYTHING, &arg);
     573                 :        2011 : }
     574                 :             : 
     575                 :             : /*
     576                 :             :  * BoxedInstance::set_nested_interface_object:
     577                 :             :  * @field_info: introspection info for the field of the parent boxed type that
     578                 :             :  *   is another boxed type
     579                 :             :  * @interface_info: introspection info for the nested boxed type
     580                 :             :  * @value: holds a BoxedInstance JS object of type @interface_info
     581                 :             :  *
     582                 :             :  * Some boxed types have a field that consists of another boxed type. This
     583                 :             :  * method is called from BoxedInstance::field_setter_impl() when any such field
     584                 :             :  * is being set. The contents of the BoxedInstance JS object in @value are
     585                 :             :  * copied into the correct place in this BoxedInstance's memory.
     586                 :             :  */
     587                 :           3 : bool BoxedInstance::set_nested_interface_object(
     588                 :             :     JSContext* context, const GI::FieldInfo field_info,
     589                 :             :     const GI::StructInfo struct_info, JS::HandleValue value) {
     590         [ -  + ]:           3 :     if (!struct_is_simple(struct_info)) {
     591                 :           0 :         gjs_throw(context, "Writing field %s.%s is not supported",
     592                 :           0 :                   format_name().c_str(), field_info.name());
     593                 :             : 
     594                 :           0 :         return false;
     595                 :             :     }
     596                 :             : 
     597                 :             :     JS::RootedObject proto{context,
     598                 :           3 :                            gjs_lookup_generic_prototype(context, struct_info)};
     599                 :             : 
     600         [ -  + ]:           3 :     if (!proto)
     601                 :           0 :         return false;
     602                 :             : 
     603                 :             :     /* If we can't directly copy from the source object we need
     604                 :             :      * to construct a new temporary object.
     605                 :             :      */
     606                 :           3 :     BoxedBase* source_priv = get_copy_source(context, value);
     607         [ +  - ]:           3 :     if (!source_priv) {
     608                 :           3 :         JS::RootedValueArray<1> args(context);
     609                 :           3 :         args[0].set(value);
     610                 :             :         JS::RootedObject tmp_object(context,
     611                 :           3 :             gjs_construct_object_dynamic(context, proto, args));
     612   [ +  -  -  +  :           3 :         if (!tmp_object || !for_js_typecheck(context, tmp_object, &source_priv))
                   -  + ]
     613                 :           0 :             return false;
     614   [ +  -  +  - ]:           3 :     }
     615                 :             : 
     616         [ -  + ]:           3 :     if (!source_priv->check_is_instance(context, "copy"))
     617                 :           0 :         return false;
     618                 :             : 
     619                 :           3 :     memcpy(raw_ptr() + field_info.offset(), source_priv->to_instance()->ptr(),
     620                 :           3 :            source_priv->info().size());
     621                 :             : 
     622                 :           3 :     return true;
     623                 :           3 : }
     624                 :             : 
     625                 :             : // See BoxedBase::field_setter().
     626                 :         199 : bool BoxedInstance::field_setter_impl(JSContext* context,
     627                 :             :                                       const GI::FieldInfo field_info,
     628                 :             :                                       JS::HandleValue value) {
     629                 :         199 :     GI::AutoTypeInfo type_info{field_info.type_info()};
     630                 :             : 
     631   [ +  +  +  +  :         199 :     if (!type_info.is_pointer() && type_info.tag() == GI_TYPE_TAG_INTERFACE) {
                   +  + ]
     632                 :          22 :         GI::AutoBaseInfo interface_info{type_info.interface()};
     633         [ +  + ]:          22 :         if (auto struct_info = interface_info.as<GI::InfoTag::STRUCT>()) {
     634                 :           3 :             return set_nested_interface_object(context, field_info,
     635                 :           6 :                                                struct_info.value(), value);
     636         [ +  + ]:          22 :         }
     637         [ +  + ]:          22 :     }
     638                 :             : 
     639                 :             :     GIArgument arg;
     640         [ -  + ]:         196 :     if (!gjs_value_to_gi_argument(context, value, type_info, field_info.name(),
     641                 :             :                                   GJS_ARGUMENT_FIELD, GI_TRANSFER_NOTHING,
     642                 :             :                                   GjsArgumentFlags::MAY_BE_NULL, &arg))
     643                 :           0 :         return false;
     644                 :             : 
     645                 :         196 :     bool success = true;
     646         [ +  + ]:         196 :     if (field_info.write(m_ptr, &arg).isErr()) {
     647                 :           2 :         gjs_throw(context, "Writing field %s.%s is not supported",
     648                 :           2 :                   format_name().c_str(), field_info.name());
     649                 :           1 :         success = false;
     650                 :             :     }
     651                 :             : 
     652                 :         196 :     JS::AutoSaveExceptionState saved_exc(context);
     653         [ -  + ]:         196 :     if (!gjs_gi_argument_release(context, GI_TRANSFER_NOTHING, type_info,
     654                 :             :                                  GjsArgumentFlags::ARG_IN, &arg))
     655                 :           0 :         gjs_log_exception(context);
     656                 :         196 :     saved_exc.restore();
     657                 :             : 
     658                 :         196 :     return success;
     659                 :         199 : }
     660                 :             : 
     661                 :             : /*
     662                 :             :  * BoxedBase::field_setter:
     663                 :             :  *
     664                 :             :  * JSNative property setter that is called when writing to a field defined on a
     665                 :             :  * boxed type. Delegates to BoxedInstance::field_setter_impl() if the minimal
     666                 :             :  * conditions have been met.
     667                 :             :  */
     668                 :          84 : bool BoxedBase::field_setter(JSContext* cx, unsigned argc, JS::Value* vp) {
     669   [ -  +  -  + ]:          84 :     GJS_CHECK_WRAPPER_PRIV(cx, argc, vp, args, obj, BoxedBase, priv);
     670         [ -  + ]:          84 :     if (!priv->check_is_instance(cx, "set a field"))
     671                 :           0 :         return false;
     672                 :             : 
     673                 :          84 :     uint32_t field_ix = gjs_dynamic_property_private_slot(&args.callee())
     674                 :          84 :         .toPrivateUint32();
     675                 :          84 :     Maybe<GI::AutoFieldInfo> field_info{priv->get_field_info(cx, field_ix)};
     676         [ -  + ]:          84 :     if (!field_info)
     677                 :           0 :         return false;
     678                 :             : 
     679         [ +  + ]:          84 :     if (!priv->to_instance()->field_setter_impl(cx, *field_info, args[0]))
     680                 :           1 :         return false;
     681                 :             : 
     682                 :          83 :     args.rval().setUndefined();  /* No stored value */
     683                 :          83 :     return true;
     684                 :          84 : }
     685                 :             : 
     686                 :             : /*
     687                 :             :  * BoxedPrototype::define_boxed_class_fields:
     688                 :             :  *
     689                 :             :  * Defines properties on the JS prototype object, with JSNative getters and
     690                 :             :  * setters, for all the fields exposed by GObject introspection.
     691                 :             :  */
     692                 :         879 : bool BoxedPrototype::define_boxed_class_fields(JSContext* cx,
     693                 :             :                                                JS::HandleObject proto) {
     694                 :         879 :     uint32_t count = 0;
     695                 :             : 
     696                 :             :     // We define all fields as read/write so that the user gets an error
     697                 :             :     // message. If we omitted fields or defined them read-only we'd:
     698                 :             :     //
     699                 :             :     //  - Store a new property for a non-accessible field
     700                 :             :     //  - Silently do nothing when writing a read-only field
     701                 :             :     //
     702                 :             :     // Which is pretty confusing if the only reason a field isn't writable is
     703                 :             :     // language binding or memory-management restrictions.
     704                 :             :     //
     705                 :             :     // We just go ahead and define the fields immediately for the class; doing
     706                 :             :     // it lazily in boxed_resolve() would be possible as well if doing it ahead
     707                 :             :     // of time caused too much start-up memory overhead.
     708                 :             :     //
     709                 :             :     // At this point methods have already been defined on the prototype, so we
     710                 :             :     // may get name conflicts which we need to check for.
     711         [ +  + ]:        2909 :     for (GI::AutoFieldInfo field : info().fields()) {
     712                 :        2030 :         JS::RootedValue private_id{cx, JS::PrivateUint32Value(count++)};
     713                 :        2030 :         JS::RootedId id{cx, gjs_intern_string_to_id(cx, field.name())};
     714                 :             : 
     715                 :             :         bool already_defined;
     716         [ -  + ]:        2030 :         if (!JS_HasOwnPropertyById(cx, proto, id, &already_defined))
     717                 :           0 :             return false;
     718         [ +  + ]:        2030 :         if (already_defined) {
     719                 :           2 :             gjs_debug(GJS_DEBUG_GBOXED,
     720                 :             :                       "Field %s.%s overlaps with method of the same name; "
     721                 :             :                       "skipping",
     722                 :           2 :                       format_name().c_str(), field.name());
     723                 :           1 :             continue;
     724                 :             :         }
     725                 :             : 
     726         [ -  + ]:        2029 :         if (!gjs_define_property_dynamic(
     727                 :             :                 cx, proto, field.name(), id, "boxed_field",
     728                 :             :                 &BoxedBase::field_getter, &BoxedBase::field_setter, private_id,
     729                 :             :                 GJS_MODULE_PROP_FLAGS))
     730                 :           0 :             return false;
     731   [ +  -  +  +  :        2032 :     }
             -  +  +  -  
                      + ]
     732                 :             : 
     733                 :         879 :     return true;
     734                 :             : }
     735                 :             : 
     736                 :             : // Overrides GIWrapperPrototype::trace_impl().
     737                 :        1798 : void BoxedPrototype::trace_impl(JSTracer* trc) {
     738                 :        1798 :     JS::TraceEdge<jsid>(trc, &m_default_constructor_name,
     739                 :             :                         "Boxed::default_constructor_name");
     740         [ +  + ]:        1798 :     if (m_field_map)
     741                 :          15 :         m_field_map->trace(trc);
     742                 :        1798 : }
     743                 :             : 
     744                 :             : // clang-format off
     745                 :             : const struct JSClassOps BoxedBase::class_ops = {
     746                 :             :     nullptr,  // addProperty
     747                 :             :     nullptr,  // deleteProperty
     748                 :             :     nullptr,  // enumerate
     749                 :             :     &BoxedBase::new_enumerate,
     750                 :             :     &BoxedBase::resolve,
     751                 :             :     nullptr,  // mayResolve
     752                 :             :     &BoxedBase::finalize,
     753                 :             :     nullptr,  // call
     754                 :             :     nullptr,  // construct
     755                 :             :     &BoxedBase::trace
     756                 :             : };
     757                 :             : 
     758                 :             : /* We allocate 1 extra reserved slot; this is typically unused, but if the
     759                 :             :  * boxed is for a nested structure inside a parent structure, the
     760                 :             :  * reserved slot is used to hold onto the parent Javascript object and
     761                 :             :  * make sure it doesn't get freed.
     762                 :             :  */
     763                 :             : const struct JSClass BoxedBase::klass = {
     764                 :             :     "GObject_Boxed",
     765                 :             :     JSCLASS_HAS_RESERVED_SLOTS(2) | JSCLASS_FOREGROUND_FINALIZE,
     766                 :             :     &BoxedBase::class_ops
     767                 :             : };
     768                 :             : // clang-format on
     769                 :             : 
     770                 :             : [[nodiscard]]
     771                 :        4076 : static bool type_can_be_allocated_directly(const GI::TypeInfo& type_info) {
     772         [ +  + ]:        4076 :     if (type_info.is_pointer()) {
     773   [ +  +  +  -  :        2348 :         if (type_info.tag() == GI_TYPE_TAG_ARRAY &&
                   +  + ]
     774                 :         344 :             type_info.array_type() == GI_ARRAY_TYPE_C)
     775                 :         344 :             return type_can_be_allocated_directly(type_info.element_type());
     776                 :             : 
     777                 :        1660 :         return true;
     778                 :             :     }
     779                 :             : 
     780         [ +  + ]:        2072 :     if (type_info.tag() != GI_TYPE_TAG_INTERFACE)
     781                 :        1782 :         return true;
     782                 :             : 
     783                 :         290 :     GI::AutoBaseInfo interface_info{type_info.interface()};
     784         [ +  + ]:         290 :     if (auto struct_info = interface_info.as<GI::InfoTag::STRUCT>())
     785         [ +  + ]:         290 :         return struct_is_simple(struct_info.value());
     786         [ -  + ]:         280 :     if (interface_info.is_union())
     787                 :           0 :         return false;  // FIXME: Need to implement
     788         [ +  + ]:         280 :     if (interface_info.is_enum_or_flags())
     789                 :         216 :         return true;
     790         [ -  + ]:          64 :     if (interface_info.type() == GI_INFO_TYPE_INVALID_0)
     791                 :             :         g_assert_not_reached();
     792                 :          64 :     return false;
     793                 :         290 : }
     794                 :             : 
     795                 :             : [[nodiscard]]
     796                 :             : static bool simple_struct_has_pointers(const GI::StructInfo);
     797                 :             : 
     798                 :             : [[nodiscard]]
     799                 :         746 : static bool direct_allocation_has_pointers(const GI::TypeInfo type_info) {
     800         [ +  + ]:         746 :     if (type_info.is_pointer()) {
     801   [ +  +  +  -  :         272 :         if (type_info.tag() == GI_TYPE_TAG_ARRAY &&
                   +  + ]
     802                 :           1 :             type_info.array_type() == GI_ARRAY_TYPE_C) {
     803                 :           1 :             return direct_allocation_has_pointers(type_info.element_type());
     804                 :             :         }
     805                 :             : 
     806                 :         270 :         return type_info.tag() != GI_TYPE_TAG_VOID;
     807                 :             :     }
     808                 :             : 
     809         [ +  + ]:         475 :     if (type_info.tag() != GI_TYPE_TAG_INTERFACE)
     810                 :         417 :         return false;
     811                 :             : 
     812                 :          58 :     GI::AutoBaseInfo interface{type_info.interface()};
     813         [ +  + ]:          58 :     if (auto struct_info = interface.as<GI::InfoTag::STRUCT>())
     814         [ +  + ]:          58 :         return simple_struct_has_pointers(struct_info.value());
     815                 :             : 
     816                 :          55 :     return false;
     817                 :          58 : }
     818                 :             : 
     819                 :             : /* Check if the type of the boxed is "simple" - every field is a non-pointer
     820                 :             :  * type that we know how to assign to. If so, then we can allocate and free
     821                 :             :  * instances without needing a constructor.
     822                 :             :  */
     823                 :             : [[nodiscard]]
     824                 :        1221 : bool struct_is_simple(const GI::StructInfo& info) {
     825                 :        1221 :     GI::StructInfo::FieldsIterator iter = info.fields();
     826                 :             : 
     827                 :             :     // If it's opaque, it's not simple
     828         [ +  + ]:        1221 :     if (iter.size() == 0)
     829                 :         505 :         return false;
     830                 :             : 
     831                 :         716 :     return std::all_of(
     832                 :        3732 :         iter.begin(), iter.end(), [](GI::AutoFieldInfo field_info) {
     833                 :        3732 :             return type_can_be_allocated_directly(field_info.type_info());
     834                 :         716 :         });
     835                 :             : }
     836                 :             : 
     837                 :             : [[nodiscard]]
     838                 :         313 : static bool simple_struct_has_pointers(const GI::StructInfo info) {
     839                 :         313 :     g_assert(struct_is_simple(info) &&
     840                 :             :              "Don't call simple_struct_has_pointers() on a non-simple struct");
     841                 :             : 
     842                 :         313 :     GI::StructInfo::FieldsIterator fields = info.fields();
     843                 :         313 :     return std::any_of(
     844                 :         745 :         fields.begin(), fields.end(), [](GI::AutoFieldInfo field) {
     845                 :         745 :             return direct_allocation_has_pointers(field.type_info());
     846                 :         313 :         });
     847                 :             : }
     848                 :             : 
     849                 :         879 : BoxedPrototype::BoxedPrototype(const GI::StructInfo info, GType gtype)
     850                 :             :     : GIWrapperPrototype(info, gtype),
     851                 :         879 :       m_zero_args_constructor(-1),
     852                 :         879 :       m_default_constructor(-1),
     853                 :         879 :       m_default_constructor_name(JS::PropertyKey::Void()),
     854                 :        1758 :       m_can_allocate_directly(struct_is_simple(info)) {
     855         [ +  + ]:         879 :     if (!m_can_allocate_directly) {
     856                 :         569 :         m_can_allocate_directly_without_pointers = false;
     857                 :             :     } else {
     858                 :         310 :         m_can_allocate_directly_without_pointers =
     859                 :         310 :             !simple_struct_has_pointers(info);
     860                 :             :     }
     861                 :         879 :     GJS_INC_COUNTER(boxed_prototype);
     862                 :         879 : }
     863                 :             : 
     864                 :             : // Overrides GIWrapperPrototype::init().
     865                 :         879 : bool BoxedPrototype::init(JSContext* context) {
     866                 :         879 :     int i = 0;
     867                 :         879 :     int first_constructor = -1;
     868                 :         879 :     jsid first_constructor_name = JS::PropertyKey::Void();
     869                 :         879 :     jsid zero_args_constructor_name = JS::PropertyKey::Void();
     870                 :             : 
     871         [ +  + ]:         879 :     if (m_gtype != G_TYPE_NONE) {
     872                 :             :         /* If the structure is registered as a boxed, we can create a new instance by
     873                 :             :          * looking for a zero-args constructor and calling it; constructors don't
     874                 :             :          * really make sense for non-boxed types, since there is no memory management
     875                 :             :          * for the return value.
     876                 :             :          */
     877         [ +  + ]:       17748 :         for (GI::AutoFunctionInfo func_info : m_info.methods()) {
     878         [ +  + ]:       16948 :             if (func_info.is_constructor()) {
     879         [ +  + ]:        2230 :                 if (first_constructor < 0) {
     880                 :         542 :                     first_constructor = i;
     881                 :             :                     first_constructor_name =
     882                 :         542 :                         gjs_intern_string_to_id(context, func_info.name());
     883         [ -  + ]:         542 :                     if (first_constructor_name.isVoid())
     884                 :           0 :                         return false;
     885                 :             :                 }
     886                 :             : 
     887   [ +  +  +  +  :        2230 :                 if (m_zero_args_constructor < 0 && func_info.n_args() == 0) {
                   +  + ]
     888                 :          14 :                     m_zero_args_constructor = i;
     889                 :             :                     zero_args_constructor_name =
     890                 :          14 :                         gjs_intern_string_to_id(context, func_info.name());
     891         [ -  + ]:          14 :                     if (zero_args_constructor_name.isVoid())
     892                 :           0 :                         return false;
     893                 :             :                 }
     894                 :             : 
     895   [ +  +  +  + ]:        4286 :                 if (m_default_constructor < 0 &&
     896         [ +  + ]:        2056 :                     strcmp(func_info.name(), "new") == 0) {
     897                 :         389 :                     m_default_constructor = i;
     898                 :         389 :                     const GjsAtoms& atoms = GjsContextPrivate::atoms(context);
     899                 :         389 :                     m_default_constructor_name = atoms.new_();
     900                 :             :                 }
     901                 :             :             }
     902                 :       16948 :             i++;
     903         [ +  - ]:       16948 :         }
     904                 :             : 
     905         [ +  + ]:         800 :         if (m_default_constructor < 0) {
     906                 :         411 :             m_default_constructor = m_zero_args_constructor;
     907                 :         411 :             m_default_constructor_name = zero_args_constructor_name;
     908                 :             :         }
     909         [ +  + ]:         800 :         if (m_default_constructor < 0) {
     910                 :         410 :             m_default_constructor = first_constructor;
     911                 :         410 :             m_default_constructor_name = first_constructor_name;
     912                 :             :         }
     913                 :             :     }
     914                 :             : 
     915                 :         879 :     return true;
     916                 :             : }
     917                 :             : 
     918                 :             : /*
     919                 :             :  * BoxedPrototype::define_class:
     920                 :             :  * @in_object: Object where the constructor is stored, typically a repo object.
     921                 :             :  * @info: Introspection info for the boxed class.
     922                 :             :  *
     923                 :             :  * Define a boxed class constructor and prototype, including all the necessary
     924                 :             :  * methods and properties.
     925                 :             :  */
     926                 :         879 : bool BoxedPrototype::define_class(JSContext* context,
     927                 :             :                                   JS::HandleObject in_object,
     928                 :             :                                   const GI::StructInfo info) {
     929                 :         879 :     JS::RootedObject prototype(context), unused_constructor(context);
     930                 :         879 :     GType gtype = info.gtype();
     931                 :         879 :     BoxedPrototype* priv = BoxedPrototype::create_class(
     932                 :             :         context, in_object, info, gtype, &unused_constructor, &prototype);
     933   [ +  -  -  +  :         879 :     if (!priv || !priv->define_boxed_class_fields(context, prototype))
                   -  + ]
     934                 :           0 :         return false;
     935                 :             : 
     936   [ +  +  -  + ]:         942 :     if (gtype == G_TYPE_ERROR &&
     937         [ -  + ]:         942 :         !JS_DefineFunction(context, prototype, "toString",
     938                 :             :                            &ErrorBase::to_string, 0, GJS_MODULE_PROP_FLAGS))
     939                 :           0 :         return false;
     940                 :             : 
     941                 :         879 :     return true;
     942                 :         879 : }
     943                 :             : 
     944                 :             : /* Helper function to make the public API more readable. The overloads are
     945                 :             :  * specified explicitly in the public API, but the implementation uses
     946                 :             :  * std::forward in order to avoid duplicating code. */
     947                 :             : template <typename... Args>
     948                 :       19031 : JSObject* BoxedInstance::new_for_c_struct_impl(JSContext* cx,
     949                 :             :                                                const GI::StructInfo info,
     950                 :             :                                                void* gboxed, Args&&... args) {
     951         [ -  + ]:       19031 :     if (gboxed == NULL)
     952                 :           0 :         return NULL;
     953                 :             : 
     954                 :             :     gjs_debug_marshal(GJS_DEBUG_GBOXED, "Wrapping struct %s %p with JSObject",
     955                 :             :                       info.name(), gboxed);
     956                 :             : 
     957                 :       19031 :     JS::RootedObject obj(cx, gjs_new_object_with_generic_prototype(cx, info));
     958         [ -  + ]:       19031 :     if (!obj)
     959                 :           0 :         return nullptr;
     960                 :             : 
     961                 :       19031 :     BoxedInstance* priv = BoxedInstance::new_for_js_object(cx, obj);
     962         [ -  + ]:       19031 :     if (!priv)
     963                 :           0 :         return nullptr;
     964                 :             : 
     965         [ -  + ]:       19031 :     if (!priv->init_from_c_struct(cx, gboxed, std::forward<Args>(args)...))
     966                 :           0 :         return nullptr;
     967                 :             : 
     968   [ +  +  -  +  :       19031 :     if (priv->gtype() == G_TYPE_ERROR && !gjs_define_error_properties(cx, obj))
                   -  + ]
     969                 :           0 :         return nullptr;
     970                 :             : 
     971                 :       19031 :     return obj;
     972                 :       19031 : }
     973                 :             : 
     974                 :             : /*
     975                 :             :  * BoxedInstance::new_for_c_struct:
     976                 :             :  *
     977                 :             :  * Creates a new BoxedInstance JS object from a C boxed struct pointer.
     978                 :             :  *
     979                 :             :  * There are two overloads of this method; the NoCopy overload will simply take
     980                 :             :  * the passed-in pointer but not own it, while the normal method will take a
     981                 :             :  * reference, or if the boxed type can be directly allocated, copy the memory.
     982                 :             :  */
     983                 :       19017 : JSObject* BoxedInstance::new_for_c_struct(JSContext* cx,
     984                 :             :                                           const GI::StructInfo info,
     985                 :             :                                           void* gboxed) {
     986                 :       19017 :     return new_for_c_struct_impl(cx, info, gboxed);
     987                 :             : }
     988                 :             : 
     989                 :          14 : JSObject* BoxedInstance::new_for_c_struct(JSContext* cx,
     990                 :             :                                           const GI::StructInfo info,
     991                 :             :                                           void* gboxed, NoCopy no_copy) {
     992                 :          14 :     return new_for_c_struct_impl(cx, info, gboxed, no_copy);
     993                 :             : }
     994                 :             : 
     995                 :             : /*
     996                 :             :  * BoxedInstance::init_from_c_struct:
     997                 :             :  *
     998                 :             :  * Do the necessary initialization when creating a BoxedInstance JS object from
     999                 :             :  * a C boxed struct pointer.
    1000                 :             :  *
    1001                 :             :  * There are two overloads of this method; the NoCopy overload will simply take
    1002                 :             :  * the passed-in pointer, while the normal method will take a reference, or if
    1003                 :             :  * the boxed type can be directly allocated, copy the memory.
    1004                 :             :  */
    1005                 :          14 : bool BoxedInstance::init_from_c_struct(JSContext*, void* gboxed, NoCopy) {
    1006                 :             :     // We need to create a JS Boxed which references the original C struct, not
    1007                 :             :     // a copy of it. Used for G_SIGNAL_TYPE_STATIC_SCOPE.
    1008                 :          14 :     share_ptr(gboxed);
    1009                 :          14 :     debug_lifecycle("Boxed pointer acquired, memory not owned");
    1010                 :          14 :     return true;
    1011                 :             : }
    1012                 :             : 
    1013                 :       19017 : bool BoxedInstance::init_from_c_struct(JSContext* cx, void* gboxed) {
    1014   [ +  +  +  -  :       19017 :     if (gtype() != G_TYPE_NONE && g_type_is_a(gtype(), G_TYPE_BOXED)) {
             +  +  +  + ]
    1015                 :       15660 :         copy_boxed(gboxed);
    1016                 :       15660 :         return true;
    1017         [ +  + ]:        3357 :     } else if (gtype() == G_TYPE_VARIANT) {
    1018                 :        3332 :         own_ptr(g_variant_ref_sink(static_cast<GVariant*>(gboxed)));
    1019                 :        3332 :         debug_lifecycle("Boxed pointer created by sinking GVariant ref");
    1020                 :        3332 :         return true;
    1021         [ +  - ]:          25 :     } else if (get_prototype()->can_allocate_directly()) {
    1022                 :          25 :         copy_memory(gboxed);
    1023                 :          25 :         return true;
    1024                 :             :     }
    1025                 :             : 
    1026                 :           0 :     gjs_throw(cx, "Can't create a Javascript object for %s; no way to copy",
    1027                 :             :               name());
    1028                 :           0 :     return false;
    1029                 :             : }
    1030                 :             : 
    1031                 :         109 : void* BoxedInstance::copy_ptr(JSContext* cx, GType gtype, void* ptr) {
    1032   [ +  -  +  +  :         109 :     if (g_type_is_a(gtype, G_TYPE_BOXED))
                   +  + ]
    1033                 :         107 :         return g_boxed_copy(gtype, ptr);
    1034   [ -  +  -  -  :           2 :     if (g_type_is_a(gtype, G_TYPE_VARIANT))
                   +  - ]
    1035                 :           2 :         return g_variant_ref(static_cast<GVariant*>(ptr));
    1036                 :             : 
    1037                 :           0 :     gjs_throw(cx,
    1038                 :             :               "Can't transfer ownership of a structure type not registered as "
    1039                 :             :               "boxed");
    1040                 :           0 :     return nullptr;
    1041                 :             : }
        

Generated by: LCOV version 2.0-1