@gjsify/node-gi 0.63.0 → 0.64.1

package/index.d.ts

@@ -56,17 +56,18 @@ export function getEnumValues(namespace: string, name: string): Record<string, n
 export function getErrorDomain(namespace: string, name: string): { name: string; quark: number } | null;
 
 /**
- * Register the L1 GLib.Error factory the engine calls when a GI invoke fails, so
- * a failed sync call throws a real `GLib.Error` (instanceof, with `.matches()`),
- * together with the CLASS it builds — which a `GError`-typed IN argument uses to
- * recognise such an error coming back and rebuild a real `GError` from its
- * fields. Without the class that direction accepts only a marshalled (boxed)
- * error, so a caught one cannot be handed on.
- */
-export function setErrorBuilder(
-    builder: (domainName: string, domainQuark: number, code: number, message: string) => Error,
-    errorClass?: new (domain: unknown, code: number, message: string) => Error,
-): void;
+ * Resolve a domain quark back to the enum type registered for it — the reverse of
+ * {@link getErrorDomain}, so a thrown error reaches its domain class even when
+ * nothing has touched that enum yet. `null` for a quark no typelib claims.
+ */
+export function errorDomainInfo(quark: number): { namespace: string; name: string } | null;
+
+/**
+ * Register the L1 `GLib.Error` factory the engine calls when a GI invoke fails. It
+ * receives the failed call's `GError` as a boxed handle, having taken ownership of
+ * it, and returns the object to throw — the same shape a marshalled error gets.
+ */
+export function setErrorBuilder(builder: (handle: BoxedHandle) => unknown): void;
 
 /** Prepend a directory to the GIRepository typelib search path. */
 export function prependSearchPath(path: string): void;
@@ -599,6 +600,7 @@ declare const native: {
     getConstantValue: typeof getConstantValue;
     getEnumValues: typeof getEnumValues;
     getErrorDomain: typeof getErrorDomain;
+    errorDomainInfo: typeof errorDomainInfo;
     setErrorBuilder: typeof setErrorBuilder;
     prependSearchPath: typeof prependSearchPath;
     prependLibraryPath: typeof prependLibraryPath;

package/index.js

@@ -29,6 +29,7 @@ export const findInfo = native.findInfo;
 export const getConstantValue = native.getConstantValue;
 export const getEnumValues = native.getEnumValues;
 export const getErrorDomain = native.getErrorDomain;
+export const errorDomainInfo = native.errorDomainInfo;
 export const setErrorBuilder = native.setErrorBuilder;
 export const prependSearchPath = native.prependSearchPath;
 export const prependLibraryPath = native.prependLibraryPath;

package/overrides/gio-settings.js

@@ -10,16 +10,8 @@
 // throws; this is the same wrapper, so `try { … } catch` means the same on either runtime
 // (ADR 0099 conformance row `errors`).
 //
-// Two deliberate differences from the GJS override:
-//   • the constructor check is a Proxy `construct` trap — a node-gi class has no `_init` to wrap;
-//   • `set_int` / `set_uint` range-check their value, which in GJS is the argument marshaller's
-//     job. node-gi's marshaller wraps modulo 2^32 (`set_uint('k', -1)` stores 4294967295), a
-//     general divergence recorded in status/open-todos/node-gi.md; this keeps the settings
-//     surface honest without touching the addon, so it also holds in an already-built payload.
-
-const INT32_MIN = -(2 ** 31);
-const INT32_MAX = 2 ** 31 - 1;
-const UINT32_MAX = 2 ** 32 - 1;
+// One deliberate difference from the GJS override: the constructor check is a Proxy `construct`
+// trap — a node-gi class has no `_init` to wrap.
 
 const CHECKED = [
     'get_boolean',
@@ -53,12 +45,6 @@ const CHECKED = [
     'reset',
 ];
 
-/** The range a setter's JS number must be in; GJS's marshaller throws this exact message. */
-const RANGES = {
-    set_int: [INT32_MIN, INT32_MAX, 'int32'],
-    set_uint: [0, UINT32_MAX, 'uint32'],
-};
-
 /**
  * Patch `Gio.Settings` / `Gio.SettingsSchema` like GJS does, once, and return the class to hand
  * out (a Proxy whose `new` refuses a schema that is not installed instead of aborting).
@@ -87,16 +73,8 @@ export function createGioSettings(Gio) {
     for (const name of CHECKED) {
         const real = proto[name];
         if (typeof real !== 'function') continue;
-        const range = RANGES[name];
         proto[name] = function (key, ...args) {
             checkKey(this, key);
-            if (range !== undefined) {
-                const [min, max, type] = range;
-                const value = args[0];
-                if (typeof value !== 'number' || !Number.isFinite(value) || value < min || value > max) {
-                    throw new Error(`Argument value: value is out of range for ${type}`);
-                }
-            }
             return real.call(this, key, ...args);
         };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gjsify/node-gi",
-  "version": "0.63.0",
+  "version": "0.64.1",
   "description": "GObject-Introspection runtime for Node.js — load gi:// namespaces (GLib/GObject/Gio/…) with GJS-compatible semantics. Vendored + rewritten from node-gtk under MIT.",
   "type": "module",
   "license": "MIT",

package/src/addon.cc

@@ -88,6 +88,7 @@ static Napi::Object Init(Napi::Env env, Napi::Object exports) {
   exports.Set("getConstantValue", Napi::Function::New(env, GetConstantValue));
   exports.Set("getEnumValues", Napi::Function::New(env, GetEnumValues));
   exports.Set("getErrorDomain", Napi::Function::New(env, GetErrorDomain));
+  exports.Set("errorDomainInfo", Napi::Function::New(env, ErrorDomainInfo));
   exports.Set("setErrorBuilder", Napi::Function::New(env, SetErrorBuilder));
   exports.Set("prependSearchPath", Napi::Function::New(env, PrependSearchPath));
   exports.Set("prependLibraryPath", Napi::Function::New(env, PrependLibraryPath));

package/src/cairo.cc

@@ -17,7 +17,8 @@
 // WrapBoxed; cairo_path_t is NOT ref-counted, so a borrowed path is COPIED via
 // the gjs CairoPath::copy_ptr dummy-context trick instead of ref'd). Slice:
 // Context (drawing ops, path copy/append, dash, matrix point transforms,
-// in-fill/in-stroke, getSource), Surface + ImageSurface (headless pixels),
+// in-fill/in-stroke, getSource, the toy-text API: selectFontFace/setFontSize/
+// showText/textPath/textExtents/fontExtents), Surface + ImageSurface (headless pixels),
 // SolidPattern, LinearGradient/RadialGradient (color stops), SurfacePattern
 // (extend/filter), Path handles. Deferred: region, PDF/SVG/PS surfaces,
 // text/font ops (showText/selectFontFace — canvas2d text rides PangoCairo).
@@ -733,6 +734,70 @@ void InitCairo(Napi::Env env, Napi::Object exports) {
   CTX_EXTENTS("fillExtents", cairo_fill_extents)
   CTX_EXTENTS("strokeExtents", cairo_stroke_extents)
   CTX_EXTENTS("clipExtents", cairo_clip_extents)
+  // Toy text API (cairo_select_font_face & co), the GJS-compatible Context text ops.
+  // textExtents/fontExtents return the object shape gjs's cairo-context.cpp builds.
+  c.Set("selectFontFace", Napi::Function::New(env, +[](const Napi::CallbackInfo& info) -> Napi::Value {
+          Napi::Env env = info.Env();
+          cairo_t* cr = CtxArg(env, info);
+          if (cr == nullptr) return env.Undefined();
+          std::string family = info[1].ToString().Utf8Value();
+          cairo_select_font_face(cr, family.c_str(),
+                                 static_cast<cairo_font_slant_t>(info[2].ToNumber().Int32Value()),
+                                 static_cast<cairo_font_weight_t>(info[3].ToNumber().Int32Value()));
+          CheckStatus(env, cairo_status(cr), "selectFontFace");
+          return env.Undefined();
+        }));
+  c.Set("setFontSize", Napi::Function::New(env, CTX_1D(cairo_set_font_size)));
+  c.Set("showText", Napi::Function::New(env, +[](const Napi::CallbackInfo& info) -> Napi::Value {
+          Napi::Env env = info.Env();
+          cairo_t* cr = CtxArg(env, info);
+          if (cr == nullptr) return env.Undefined();
+          std::string text = info[1].ToString().Utf8Value();
+          cairo_show_text(cr, text.c_str());
+          CheckStatus(env, cairo_status(cr), "showText");
+          return env.Undefined();
+        }));
+  c.Set("textPath", Napi::Function::New(env, +[](const Napi::CallbackInfo& info) -> Napi::Value {
+          Napi::Env env = info.Env();
+          cairo_t* cr = CtxArg(env, info);
+          if (cr == nullptr) return env.Undefined();
+          std::string text = info[1].ToString().Utf8Value();
+          cairo_text_path(cr, text.c_str());
+          CheckStatus(env, cairo_status(cr), "textPath");
+          return env.Undefined();
+        }));
+  c.Set("textExtents", Napi::Function::New(env, +[](const Napi::CallbackInfo& info) -> Napi::Value {
+          Napi::Env env = info.Env();
+          cairo_t* cr = CtxArg(env, info);
+          if (cr == nullptr) return env.Undefined();
+          std::string text = info[1].ToString().Utf8Value();
+          cairo_text_extents_t e;
+          cairo_text_extents(cr, text.c_str(), &e);
+          if (!CheckStatus(env, cairo_status(cr), "textExtents")) return env.Undefined();
+          Napi::Object o = Napi::Object::New(env);
+          o.Set("xBearing", Napi::Number::New(env, e.x_bearing));
+          o.Set("yBearing", Napi::Number::New(env, e.y_bearing));
+          o.Set("width", Napi::Number::New(env, e.width));
+          o.Set("height", Napi::Number::New(env, e.height));
+          o.Set("xAdvance", Napi::Number::New(env, e.x_advance));
+          o.Set("yAdvance", Napi::Number::New(env, e.y_advance));
+          return o;
+        }));
+  c.Set("fontExtents", Napi::Function::New(env, +[](const Napi::CallbackInfo& info) -> Napi::Value {
+          Napi::Env env = info.Env();
+          cairo_t* cr = CtxArg(env, info);
+          if (cr == nullptr) return env.Undefined();
+          cairo_font_extents_t e;
+          cairo_font_extents(cr, &e);
+          if (!CheckStatus(env, cairo_status(cr), "fontExtents")) return env.Undefined();
+          Napi::Object o = Napi::Object::New(env);
+          o.Set("ascent", Napi::Number::New(env, e.ascent));
+          o.Set("descent", Napi::Number::New(env, e.descent));
+          o.Set("height", Napi::Number::New(env, e.height));
+          o.Set("maxXAdvance", Napi::Number::New(env, e.max_x_advance));
+          o.Set("maxYAdvance", Napi::Number::New(env, e.max_y_advance));
+          return o;
+        }));
   c.Set("status", Napi::Function::New(env, +[](const Napi::CallbackInfo& info) -> Napi::Value {
           Napi::Env env = info.Env();
           cairo_t* cr = CtxArg(env, info);

package/src/calls.cc

@@ -380,44 +380,40 @@ bool IsSupportedOutType(GITypeInfo* type, std::string* why) {
 
 // ---- GError -> GLib.Error ----
 //
-// A failed GI invoke yields a GError (domain quark + code + message). GJS surfaces
-// it as a real `GLib.Error` (an Error subclass carrying `.domain`/`.code`/
-// `.message` + a `.matches(domain, code)` method). The GLib.Error CLASS itself is
-// owned by L1 (gi.js) so its `matches()` can resolve an error-enum object to its
-// domain; the engine just reports the GError's fields to an L1-registered builder
-// function (stored in this env's instance data — see NodeGiEnvData) and throws
-// what it returns.
+// A failed GI invoke yields a GError (domain quark + code + message), which GJS
+// throws as the error object of that DOMAIN's class. That object is L1's to build
+// (gi.js wrapGError) — only JS can give it the Error brand, the domain class and
+// the position properties — so the engine hands the builder registered in this
+// env's instance data the one thing it needs: the `GError*` itself, as a boxed
+// handle.
 //
-// Read a GError's domain (quark name + numeric quark), code and message, FREE it,
-// and throw the JS error the L1 builder produces (instanceof GLib.Error). Falls
-// back to a plain JS Error when no builder is registered for this env. `context`
-// is the "Ns.method" display name, used only in the fallback message (a real
-// GLib.Error carries the bare GError message, matching GJS).
+// Passing the HANDLE and not the fields is the whole point. The fields used to be
+// read out, the GError g_error_free'd here, and a JS Error subclass built from
+// them — so a thrown error and a marshalled one were two different objects with
+// two different `.domain` types. Ownership now transfers to the handle, which
+// frees the GError when the JS error is collected, and both directions wrap the
+// same pointer the same way.
+//
+// Falls back to a plain JS Error when no builder is registered for this env;
+// `context` is the "Ns.method" display name, used only in that fallback message (a
+// real GLib.Error carries the bare GError message, matching GJS).
 void ThrowGError(Napi::Env env, GError* error, const std::string& context) {
-  // Read everything out of the GError BEFORE g_error_free.
-  GQuark domainQuark = error != nullptr ? error->domain : 0;
-  const char* domainName = domainQuark != 0 ? g_quark_to_string(domainQuark) : nullptr;
-  std::string domain = domainName != nullptr ? domainName : "";
-  int code = error != nullptr ? error->code : 0;
   std::string message =
       (error != nullptr && error->message != nullptr) ? error->message : "invocation failed";
-  if (error != nullptr) g_error_free(error);
 
-  // Prefer this env's L1 GLib.Error builder (instanceof GLib.Error + matches()).
   NodeGiEnvData* d = EnvData(env);
-  if (d != nullptr && d->errorBuilder != nullptr) {
+  if (error != nullptr && d != nullptr && d->errorBuilder != nullptr) {
     napi_value builder = nullptr;
     if (napi_get_reference_value(env, d->errorBuilder, &builder) == napi_ok &&
         builder != nullptr) {
       napi_value undef = nullptr;
       napi_get_undefined(env, &undef);
-      napi_value bargs[4] = {nullptr, nullptr, nullptr, nullptr};
-      napi_create_string_utf8(env, domain.c_str(), NAPI_AUTO_LENGTH, &bargs[0]);
-      napi_create_uint32(env, static_cast<uint32_t>(domainQuark), &bargs[1]);
-      napi_create_int32(env, code, &bargs[2]);
-      napi_create_string_utf8(env, message.c_str(), NAPI_AUTO_LENGTH, &bargs[3]);
+      // GI_TRANSFER_EVERYTHING: the invoke's out-GError is ours, and the handle
+      // adopts it rather than copying — so nothing frees it here.
+      napi_value handle = MakeGErrorHandle(env, error, GI_TRANSFER_EVERYTHING);
+      error = nullptr;  // adopted by the handle; no path below may free it again
       napi_value errObj = nullptr;
-      napi_status st = napi_call_function(env, undef, builder, 4, bargs, &errObj);
+      napi_status st = napi_call_function(env, undef, builder, 1, &handle, &errObj);
       if (st == napi_ok && errObj != nullptr) {
         napi_throw(env, errObj);
         return;
@@ -427,6 +423,7 @@ void ThrowGError(Napi::Env env, GError* error, const std::string& context) {
       if (napi_is_exception_pending(env, &pending) == napi_ok && pending) return;
     }
   }
+  if (error != nullptr) g_error_free(error);
   Napi::Error::New(env, "Calling " + context + ": " + message).ThrowAsJavaScriptException();
 }
 
@@ -636,7 +633,6 @@ static Napi::Value InvokeFunctionInfo(Napi::Env env, GIFunctionInfo* func, gpoin
   // belong to the callee (dropped only when the callee never ran).
   CreatedBytes createdBytes;
   CreatedValues createdValues;
-  CreatedErrors createdErrors;
   bool ok = true;
   size_t jsCursor = 0;
   std::vector<LengthWrite> lengthWrites;
@@ -815,7 +811,7 @@ static Napi::Value InvokeFunctionInfo(Napi::Env env, GIFunctionInfo* func, gpoin
           jsCursor++;
           GITransfer tr = gi_arg_info_get_ownership_transfer(ai);
           if (JsToGIArgument(env, v, ti, &slots[i], &held[i], tr, &ownedInStrings, nullptr,
-                             nullptr, nullptr, &createdErrors,
+                             nullptr, nullptr,
                              gi_base_info_get_name(reinterpret_cast<GIBaseInfo*>(ai)))) {
             in_args[inPos[i]].v_pointer = &slots[i];
             out_args[outPos[i]].v_pointer = &slots[i];
@@ -922,7 +918,7 @@ static Napi::Value InvokeFunctionInfo(Napi::Env env, GIFunctionInfo* func, gpoin
       } else {
         GITransfer tr = gi_arg_info_get_ownership_transfer(ai);
         ok = JsToGIArgument(env, v, ti, &in_args[inPos[i]], &held[i], tr, &ownedInStrings,
-                            &createdClosures, &createdBytes, &createdValues, &createdErrors,
+                            &createdClosures, &createdBytes, &createdValues,
                             gi_base_info_get_name(reinterpret_cast<GIBaseInfo*>(ai)));
       }
     }
@@ -944,9 +940,6 @@ static Napi::Value InvokeFunctionInfo(Napi::Env env, GIFunctionInfo* func, gpoin
     // Likewise every GValue boxed from a plain JS value — never adopted.
     for (GValue* gv : createdValues.transferNone) NodeGiFreeBoxedGValue(gv);
     for (GValue* gv : createdValues.transferFull) NodeGiFreeBoxedGValue(gv);
-    // Likewise every GError built from an L1 GLib.Error — never adopted.
-    for (GError* e : createdErrors.transferNone) g_error_free(e);
-    for (GError* e : createdErrors.transferFull) g_error_free(e);
     // Likewise the transfer-full-instance ref: the callee never consumed it.
     if (instanceRefTaken) g_object_unref(static_cast<GObject*>(instance));
     for (gpointer s : ownedInStrings) g_free(s);  // never reached the callee (#658)
@@ -1001,11 +994,6 @@ static Napi::Value InvokeFunctionInfo(Napi::Env env, GIFunctionInfo* func, gpoin
   // box is ours to free — success AND error paths, mirroring the GBytes rule.
   // Transfer-full GValues were adopted by the callee — no release.
   for (GValue* gv : createdValues.transferNone) NodeGiFreeBoxedGValue(gv);
-  // Transfer-none GError IN-args built from an L1 GLib.Error: the callee copied
-  // what it kept (gst_message_new_error copies the GError into the message), so
-  // the build is ours to free — success AND error paths, mirroring the two rules
-  // above. Transfer-full GErrors were adopted by the callee — no release.
-  for (GError* e : createdErrors.transferNone) g_error_free(e);
   if (!success) {
     for (const InContainer& c : inContainers) FreeInContainer(c);
     // A failed invoke did not adopt the transfer-full IN/INOUT strings we g_strdup'd
@@ -1254,6 +1242,57 @@ static GIFunctionInfo* ResolveInstanceMethod(GIRepository* repo, GType gtype, GI
   return func;
 }
 
+// Resolved instance methods, keyed by the instance's concrete GType and the name
+// as JS spelled it. The resolution above is the expensive half of a GI call —
+// dup the default repository, walk the GType parents for the nearest
+// GIObjectInfo, then search own + interface + inherited method tables twice (the
+// literal name, then the snake_case alias) — and it repeats IDENTICALLY on every
+// call, because a typelib's method tables do not change at runtime. MEASURED on
+// this machine (gjs 1.88.1 / GLib 2.88.3): `set_property` on a registerClass
+// subclass cost 8224 ns through callMethod against 2815 ns for the same
+// g_object_set_property through setProperty — 5.4 µs of pure re-resolution per
+// call, which is most of what a property write on the real-GObject engine spends.
+//
+// Only a HIT is cached. A miss must stay uncached: namespaces load lazily, so a
+// name that resolves to nothing now can resolve after the typelib that declares
+// it is required — caching the miss would make load order change behaviour.
+//
+// The cache OWNS the ref it holds (GIFunctionInfos live as long as the process
+// anyway, and the entry count is bounded by the methods a program actually
+// calls); callers get a borrowed pointer and must not unref it. Written only
+// from the JS thread, like every other entry point here.
+static std::map<std::pair<GType, std::string>, GIFunctionInfo*> g_instanceMethodCache;
+
+// The resolution of ResolveInstanceMethod, memoized. Returns a BORROWED pointer
+// (never unref) or nullptr.
+static GIFunctionInfo* ResolveInstanceMethodCached(GType gtype, const std::string& method) {
+  const std::pair<GType, std::string> key(gtype, method);
+  auto it = g_instanceMethodCache.find(key);
+  if (it != g_instanceMethodCache.end()) return it->second;
+
+  GIRepository* repo = DupDefaultRepository();
+  GIObjectInfo* objInfo = FindNearestObjectInfo(repo, gtype);
+  GIFunctionInfo* func = nullptr;
+  if (objInfo != nullptr) {
+    func = ResolveInstanceMethod(repo, gtype, objInfo, method);
+    gi_base_info_unref(objInfo);
+  }
+  g_object_unref(repo);
+  if (func != nullptr) g_instanceMethodCache.emplace(key, func);
+  return func;
+}
+
+// Whether `gtype` has introspection info at all — the distinction callMethod
+// reports as "no introspection info for X" before it even looks for a method.
+static bool HasObjectInfo(GType gtype) {
+  GIRepository* repo = DupDefaultRepository();
+  GIObjectInfo* objInfo = FindNearestObjectInfo(repo, gtype);
+  const bool found = objInfo != nullptr;
+  if (objInfo != nullptr) gi_base_info_unref(objInfo);
+  g_object_unref(repo);
+  return found;
+}
+
 // callMethod(handle, methodName, args?: unknown[]) -> unknown
 // Resolve an instance method by walking the instance's GIObjectInfo (own +
 // implemented-interface methods at each level, then up the parent chain), then
@@ -1274,20 +1313,14 @@ Napi::Value CallMethod(const Napi::CallbackInfo& info) {
                                                               : Napi::Array::New(env, 0);
 
   GType gtype = G_OBJECT_TYPE(obj);
-  GIRepository* repo = DupDefaultRepository();
+  GIFunctionInfo* func = ResolveInstanceMethodCached(gtype, method);
 
-  GIObjectInfo* objInfo = FindNearestObjectInfo(repo, gtype);
-  if (objInfo == nullptr) {
-    g_object_unref(repo);
+  if (func == nullptr && !HasObjectInfo(gtype)) {
     Napi::Error::New(env, std::string("no introspection info for ") + G_OBJECT_TYPE_NAME(obj))
         .ThrowAsJavaScriptException();
     return env.Null();
   }
 
-  GIFunctionInfo* func = ResolveInstanceMethod(repo, gtype, objInfo, method);
-  gi_base_info_unref(objInfo);
-  g_object_unref(repo);
-
   if (func == nullptr) {
     // On a terminating env the method-name read (info[1].Utf8Value) degrades to
     // "" (a swallowed napi failure), so resolution misses and we land here — but
@@ -1302,15 +1335,13 @@ Napi::Value CallMethod(const Napi::CallbackInfo& info) {
     return env.Null();
   }
   if (!gi_callable_info_is_method(reinterpret_cast<GICallableInfo*>(func))) {
-    gi_base_info_unref(func);
     Napi::TypeError::New(env, method + " is not an instance method").ThrowAsJavaScriptException();
     return env.Null();
   }
 
-  Napi::Value result =
-      InvokeFunctionInfo(env, func, obj, args, std::string(G_OBJECT_TYPE_NAME(obj)) + "." + method);
-  gi_base_info_unref(func);
-  return result;
+  // The cache owns `func`; this is a borrowed pointer.
+  return InvokeFunctionInfo(env, func, obj, args,
+                            std::string(G_OBJECT_TYPE_NAME(obj)) + "." + method);
 }
 
 // hasMethod(handle, methodName) -> boolean
@@ -1333,20 +1364,10 @@ Napi::Value HasMethod(const Napi::CallbackInfo& info) {
   if (obj == nullptr) return env.Null();
   std::string method = info[1].As<Napi::String>().Utf8Value();
 
-  GType gtype = G_OBJECT_TYPE(obj);
-  GIRepository* repo = DupDefaultRepository();
-  GIObjectInfo* objInfo = FindNearestObjectInfo(repo, gtype);
-  if (objInfo == nullptr) {
-    g_object_unref(repo);
-    return Napi::Boolean::New(env, false);
-  }
-  GIFunctionInfo* func = ResolveInstanceMethod(repo, gtype, objInfo, method);
-  gi_base_info_unref(objInfo);
-  g_object_unref(repo);
+  GIFunctionInfo* func = ResolveInstanceMethodCached(G_OBJECT_TYPE(obj), method);
   if (func == nullptr) return Napi::Boolean::New(env, false);
-  const bool invocable = gi_callable_info_is_method(reinterpret_cast<GICallableInfo*>(func));
-  gi_base_info_unref(func);
-  return Napi::Boolean::New(env, invocable);
+  return Napi::Boolean::New(env,
+                            gi_callable_info_is_method(reinterpret_cast<GICallableInfo*>(func)));
 }
 
 // hasClassMethod(namespace, typeName, methodName) -> boolean

package/src/class.cc

@@ -907,7 +907,7 @@ static Napi::Value InvokeVFuncPointer(Napi::Env env, GObject* obj, GICallableInf
         jsCursor++;
         GITransfer tr = gi_arg_info_get_ownership_transfer(ai);
         if (JsToGIArgument(env, v, ti, &slots[i], &holds[i], tr, &ownedInStrings, nullptr,
-                           nullptr, nullptr, nullptr,
+                           nullptr, nullptr,
                            gi_base_info_get_name(reinterpret_cast<GIBaseInfo*>(ai))))
           giArgs[1 + i].v_pointer = &slots[i];
         else
@@ -963,7 +963,7 @@ static Napi::Value InvokeVFuncPointer(Napi::Env env, GObject* obj, GICallableInf
       jsCursor++;
       GITransfer tr = gi_arg_info_get_ownership_transfer(ai);
       ok = JsToGIArgument(env, v, ti, &giArgs[1 + i], &holds[i], tr, &ownedInStrings, nullptr,
-                          nullptr, nullptr, nullptr,
+                          nullptr, nullptr,
                           gi_base_info_get_name(reinterpret_cast<GIBaseInfo*>(ai)));
     }