@gjsify/node-gi 0.43.0 → 0.45.0

package/src/calls.cc

@@ -432,6 +432,70 @@ void ThrowGError(Napi::Env env, GError* error, const std::string& context) {
   Napi::Error::New(env, "Calling " + context + ": " + message).ThrowAsJavaScriptException();
 }
 
+// Which of a callable's args are NOT consumed from the JS argument list:
+//  - the user_data + destroy-notify slots associated with a callback arg
+//    (filled from the callback itself);
+//  - array-length args of an array IN/OUT arg or of the return value
+//    (autofilled from the array's JS length / wired as an OUT slot; flagged
+//    in `isLenArg` so the invoke loop can tell the two skip kinds apart).
+// SHARED between the invoke loop and JsInArgCount below so the arity a
+// function REPORTS is by construction the arity the invoke CONSUMES.
+static void ComputeSkippedArgs(GICallableInfo* callable, unsigned int n_args,
+                               std::vector<bool>* skip, std::vector<bool>* isLenArg) {
+  for (unsigned int i = 0; i < n_args; i++) {
+    GIArgInfo* ai = gi_callable_info_get_arg(callable, i);
+    GITypeInfo* ti = gi_arg_info_get_type_info(ai);
+    if (gi_type_info_get_tag(ti) == GI_TYPE_TAG_INTERFACE) {
+      GIBaseInfo* iface = gi_type_info_get_interface(ti);
+      if (iface != nullptr && GI_IS_CALLBACK_INFO(iface)) {
+        int ci = ArgClosureIndex(ai);
+        int di = ArgDestroyIndex(ai);
+        if (ci >= 0 && static_cast<unsigned int>(ci) < n_args) (*skip)[ci] = true;
+        if (di >= 0 && static_cast<unsigned int>(di) < n_args) (*skip)[di] = true;
+      }
+      if (iface != nullptr) gi_base_info_unref(iface);
+    } else if (gi_type_info_get_tag(ti) == GI_TYPE_TAG_ARRAY) {
+      unsigned int L = 0;
+      if (gi_type_info_get_array_length_index(ti, &L) && L < n_args) {
+        (*skip)[L] = true;
+        (*isLenArg)[L] = true;
+      }
+    }
+    gi_base_info_unref(ti);
+    gi_base_info_unref(ai);
+  }
+  GITypeInfo* rt = gi_callable_info_get_return_type(callable);
+  if (gi_type_info_get_tag(rt) == GI_TYPE_TAG_ARRAY) {
+    unsigned int L = 0;
+    if (gi_type_info_get_array_length_index(rt, &L) && L < n_args) {
+      (*skip)[L] = true;
+      (*isLenArg)[L] = true;
+    }
+  }
+  gi_base_info_unref(rt);
+}
+
+// The number of JS arguments a callable consumes: IN/INOUT args minus the
+// skipped ones. This is what gjs reports as `Function.length` (m_js_in_argc,
+// refs/gjs/gi/function.cpp Function::init counts exactly the same set), and it
+// is what @gjsify/gtk-host's descriptor conformance reads to hold the widget
+// table against the installed typelib.
+int JsInArgCount(GICallableInfo* callable) {
+  unsigned int n_args = gi_callable_info_get_n_args(callable);
+  std::vector<bool> skip(n_args, false);
+  std::vector<bool> isLenArg(n_args, false);
+  ComputeSkippedArgs(callable, n_args, &skip, &isLenArg);
+  int count = 0;
+  for (unsigned int i = 0; i < n_args; i++) {
+    if (skip[i]) continue;
+    GIArgInfo* ai = gi_callable_info_get_arg(callable, i);
+    GIDirection d = gi_arg_info_get_direction(ai);
+    gi_base_info_unref(ai);
+    if (d == GI_DIRECTION_IN || d == GI_DIRECTION_INOUT) count++;
+  }
+  return count;
+}
+
 static Napi::Value InvokeFunctionInfo(Napi::Env env, GIFunctionInfo* func, gpointer instance,
                                       Napi::Array args, const std::string& displayName) {
   GICallableInfo* callable = reinterpret_cast<GICallableInfo*>(func);
@@ -488,56 +552,10 @@ static Napi::Value InvokeFunctionInfo(Napi::Env env, GIFunctionInfo* func, gpoin
     }
   }
 
-  // Pre-scan: the user_data + destroy-notify slots associated with a callback
-  // arg are filled from the callback, not consumed from the JS argument list.
+  // Pre-scan: which args are NOT JS-consumed (see ComputeSkippedArgs).
   std::vector<bool> skip(n_args, false);
-  for (unsigned int i = 0; i < n_args; i++) {
-    GIArgInfo* ai = gi_callable_info_get_arg(callable, i);
-    GITypeInfo* ti = gi_arg_info_get_type_info(ai);
-    if (gi_type_info_get_tag(ti) == GI_TYPE_TAG_INTERFACE) {
-      GIBaseInfo* iface = gi_type_info_get_interface(ti);
-      if (iface != nullptr && GI_IS_CALLBACK_INFO(iface)) {
-        int ci = ArgClosureIndex(ai);
-        int di = ArgDestroyIndex(ai);
-        if (ci >= 0 && static_cast<unsigned int>(ci) < n_args) skip[ci] = true;
-        if (di >= 0 && static_cast<unsigned int>(di) < n_args) skip[di] = true;
-      }
-      if (iface != nullptr) gi_base_info_unref(iface);
-    }
-    gi_base_info_unref(ti);
-    gi_base_info_unref(ai);
-  }
-
-  // Pre-scan: array-length args. An array IN/OUT arg — or the return value — may
-  // carry a separate introspectable length arg. Mark it skip (not JS-consumed)
-  // and flag it so its OUT slot is wired below / its IN value is autofilled from
-  // the array's JS length when the array arg is marshalled. This extends the same
-  // skip mechanism the callback closure/destroy slots already use.
   std::vector<bool> isLenArg(n_args, false);
-  for (unsigned int i = 0; i < n_args; i++) {
-    GIArgInfo* ai = gi_callable_info_get_arg(callable, i);
-    GITypeInfo* ti = gi_arg_info_get_type_info(ai);
-    if (gi_type_info_get_tag(ti) == GI_TYPE_TAG_ARRAY) {
-      unsigned int L = 0;
-      if (gi_type_info_get_array_length_index(ti, &L) && L < n_args) {
-        skip[L] = true;
-        isLenArg[L] = true;
-      }
-    }
-    gi_base_info_unref(ti);
-    gi_base_info_unref(ai);
-  }
-  {
-    GITypeInfo* rt = gi_callable_info_get_return_type(callable);
-    if (gi_type_info_get_tag(rt) == GI_TYPE_TAG_ARRAY) {
-      unsigned int L = 0;
-      if (gi_type_info_get_array_length_index(rt, &L) && L < n_args) {
-        skip[L] = true;
-        isLenArg[L] = true;
-      }
-    }
-    gi_base_info_unref(rt);
-  }
+  ComputeSkippedArgs(callable, n_args, &skip, &isLenArg);
 
   // Caller-allocates OUT storage (fixed C array or boxed struct): blob != nullptr
   // marks the arg; boxedGType != 0 selects the boxed copy/free path on read-back.
@@ -739,7 +757,8 @@ static Napi::Value InvokeFunctionInfo(Napi::Env env, GIFunctionInfo* func, gpoin
           Napi::Value v = jsCursor < args.Length() ? args.Get(jsCursor) : env.Undefined();
           jsCursor++;
           GITransfer tr = gi_arg_info_get_ownership_transfer(ai);
-          if (JsToGIArgument(env, v, ti, &slots[i], &held[i], tr, &ownedInStrings)) {
+          if (JsToGIArgument(env, v, ti, &slots[i], &held[i], tr, &ownedInStrings, nullptr,
+                             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];
           } else {
@@ -835,7 +854,8 @@ 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);
+                            &createdClosures, &createdBytes, &createdValues,
+                            gi_base_info_get_name(reinterpret_cast<GIBaseInfo*>(ai)));
       }
     }
 
@@ -1250,19 +1270,12 @@ Napi::Value HasMethod(const Napi::CallbackInfo& info) {
 // implemented-interface and inherited methods. Keyed by TYPE rather than by an
 // instance handle because it backs the lazy method resolution on the class
 // PROTOTYPE (#1175), which must answer before any instance exists.
-Napi::Value HasClassMethod(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  if (info.Length() < 3 || !info[0].IsString() || !info[1].IsString() || !info[2].IsString()) {
-    Napi::TypeError::New(env,
-                         "hasClassMethod(namespace: string, typeName: string, methodName: string)")
-        .ThrowAsJavaScriptException();
-    return env.Null();
-  }
-  std::string ns = info[0].As<Napi::String>().Utf8Value();
-  std::string tn = info[1].As<Napi::String>().Utf8Value();
-  std::string method = info[2].As<Napi::String>().Utf8Value();
-
-  GIRepository* repo = DupDefaultRepository();
+// The class-level resolution HasClassMethod and ClassMethodArity share: the
+// literal-then-snake_case walk over own, implemented-interface and inherited
+// methods for an object type, or the interface's own methods for an interface
+// type. Returns a new ref or nullptr.
+static GIFunctionInfo* ResolveClassLevelMethod(GIRepository* repo, const std::string& ns,
+                                               const std::string& tn, const std::string& method) {
   GIBaseInfo* base = gi_repository_find_by_name(repo, ns.c_str(), tn.c_str());
   GIFunctionInfo* func = nullptr;
   if (base != nullptr) {
@@ -1284,6 +1297,23 @@ Napi::Value HasClassMethod(const Napi::CallbackInfo& info) {
     }
     gi_base_info_unref(base);
   }
+  return func;
+}
+
+Napi::Value HasClassMethod(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 3 || !info[0].IsString() || !info[1].IsString() || !info[2].IsString()) {
+    Napi::TypeError::New(env,
+                         "hasClassMethod(namespace: string, typeName: string, methodName: string)")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  std::string ns = info[0].As<Napi::String>().Utf8Value();
+  std::string tn = info[1].As<Napi::String>().Utf8Value();
+  std::string method = info[2].As<Napi::String>().Utf8Value();
+
+  GIRepository* repo = DupDefaultRepository();
+  GIFunctionInfo* func = ResolveClassLevelMethod(repo, ns, tn, method);
   g_object_unref(repo);
   if (func == nullptr) return Napi::Boolean::New(env, false);
   const bool invocable = gi_callable_info_is_method(reinterpret_cast<GICallableInfo*>(func));
@@ -1291,6 +1321,89 @@ Napi::Value HasClassMethod(const Napi::CallbackInfo& info) {
   return Napi::Boolean::New(env, invocable);
 }
 
+// classMethodArity(namespace, typeName, methodName) -> number
+// The JS-visible IN-arg count of the method — what gjs reports as the
+// materialized function's `length` — or -1 when the name does not resolve to an
+// invocable instance method. Resolution is byte-identical to hasClassMethod
+// (shared ResolveClassLevelMethod), so `arity >= 0` IS the hasClassMethod
+// answer and the prototype materializer needs a single native call for both.
+// Arity 0 is a real answer (`Gtk.Widget.show()`), which is why absence is -1.
+Napi::Value ClassMethodArity(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  if (info.Length() < 3 || !info[0].IsString() || !info[1].IsString() || !info[2].IsString()) {
+    Napi::TypeError::New(
+        env, "classMethodArity(namespace: string, typeName: string, methodName: string)")
+        .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  std::string ns = info[0].As<Napi::String>().Utf8Value();
+  std::string tn = info[1].As<Napi::String>().Utf8Value();
+  std::string method = info[2].As<Napi::String>().Utf8Value();
+
+  GIRepository* repo = DupDefaultRepository();
+  GIFunctionInfo* func = ResolveClassLevelMethod(repo, ns, tn, method);
+  g_object_unref(repo);
+  if (func == nullptr) return Napi::Number::New(env, -1);
+  const bool invocable = gi_callable_info_is_method(reinterpret_cast<GICallableInfo*>(func));
+  const int arity = invocable ? JsInArgCount(reinterpret_cast<GICallableInfo*>(func)) : -1;
+  gi_base_info_unref(func);
+  return Napi::Number::New(env, arity);
+}
+
+// Resolve a CLASS-STRUCT method — one of the GObjectClass functions gjs exposes as a
+// STATIC on the constructor (`Gtk.Button.list_properties()`, `.find_property()`).
+// Absent from the object's own GIObjectInfo, which is why CallStaticMethod's three
+// find_method arms missed it and every such call threw "no static method '…' on
+// Ns.Class" — including @gjsify/gtk-host's paramSpecs(), on every element-creation
+// path. `list_properties` is declared on GObject.ObjectClass and NOWHERE else
+// (Gio.SimpleActionClass has no GIR record at all) and class structs carry no GI
+// inheritance, so the walk is over the object-info PARENT chain, each level's class
+// struct in turn — reproducing what gjs reaches through the CONSTRUCTOR PROTOTYPE
+// CHAIN, where gjs_define_static_methods put GObjectClass's methods on
+// GObject.Object's constructor and Gtk.Button inherits them. Returns a new ref or
+// nullptr; same shape as ResolveMethodByName's parent walk above.
+static GIFunctionInfo* ResolveClassStructMethod(GIObjectInfo* objInfo, const char* name) {
+  GIObjectInfo* walk =
+      reinterpret_cast<GIObjectInfo*>(gi_base_info_ref(reinterpret_cast<GIBaseInfo*>(objInfo)));
+  GIFunctionInfo* found = nullptr;
+  while (walk != nullptr) {
+    GIStructInfo* cs = gi_object_info_get_class_struct(walk);
+    if (cs != nullptr) {
+      if (gi_struct_info_is_gtype_struct(cs)) found = gi_struct_info_find_method(cs, name);
+      gi_base_info_unref(reinterpret_cast<GIBaseInfo*>(cs));
+    }
+    if (found != nullptr) break;
+    GIObjectInfo* parent = gi_object_info_get_parent(walk);
+    gi_base_info_unref(reinterpret_cast<GIBaseInfo*>(walk));
+    walk = parent;
+  }
+  if (walk != nullptr) gi_base_info_unref(reinterpret_cast<GIBaseInfo*>(walk));
+  return found;
+}
+
+// The GTypeClass a class-struct method runs ON: the LEAF type's class, never the
+// declarer's — list_properties() on GtkButton's class must return the button's 44
+// pspecs, not GObject's zero. gjs resolves the same way, reading the gtype off the
+// constructor the call went THROUGH (`this`), which is the leaf.
+//
+// gjs's GTypeStructInstanceIn uses g_type_class_peek and states its reason: "we use
+// peek here to simplify reference counting … GType classes are never really freed …
+// we know that the GType class is referenced at least once when the JS constructor
+// is initialized". node-gi's class proxy takes no such ref, so peek alone is nullptr
+// for a type nothing has instantiated yet — hence g_type_class_ref, to REALISE the
+// class (the same reason ConstructGObject refs it before reading its pspecs). That
+// ref is KEPT: it establishes gjs's invariant once per GType (bounded — every later
+// call is served by the peek), while unrefing is the one call that could invalidate
+// the GParamSpecs list_properties just handed out, which the class owns. Since GLib
+// 2.84 g_type_class_unref is a documented no-op, so pairing buys nothing anyway.
+static gpointer ClassStructInstance(GIObjectInfo* objInfo) {
+  GType gtype =
+      gi_registered_type_info_get_g_type(reinterpret_cast<GIRegisteredTypeInfo*>(objInfo));
+  if (gtype == G_TYPE_INVALID) return nullptr;
+  gpointer klass = g_type_class_peek(gtype);
+  return klass != nullptr ? klass : g_type_class_ref(gtype);
+}
+
 // callStaticMethod(namespace, typeName, methodName, args?) -> unknown
 // Invoke a type-level constructor/static function (e.g. Gio.File.new_for_path,
 // Gtk.Label.new) — a function found ON a type but taking no instance. The Node
@@ -1317,8 +1430,27 @@ Napi::Value CallStaticMethod(const Napi::CallbackInfo& info) {
     return env.Null();
   }
   GIFunctionInfo* func = nullptr;
+  // Non-null ONLY when the class-struct fallback is what resolved `func`: the
+  // GTypeClass to invoke it on. It doubles as the flag that the "is an instance
+  // method" rejection below must not fire — a class-struct method IS is_method,
+  // its instance is the class rather than an object.
+  gpointer classInstance = nullptr;
   if (GI_IS_OBJECT_INFO(typeInfo)) {
-    func = gi_object_info_find_method(reinterpret_cast<GIObjectInfo*>(typeInfo), method.c_str());
+    GIObjectInfo* objInfo = reinterpret_cast<GIObjectInfo*>(typeInfo);
+    func = gi_object_info_find_method(objInfo, method.c_str());
+    if (func == nullptr) {
+      func = ResolveClassStructMethod(objInfo, method.c_str());
+      if (func != nullptr) {
+        classInstance = ClassStructInstance(objInfo);
+        if (classInstance == nullptr) {
+          // No GType behind the info, so there is no class to call it on. Drop back
+          // to the plain "no static method" error rather than invoking with a null
+          // instance, which would hand the C function a null GObjectClass*.
+          gi_base_info_unref(reinterpret_cast<GIBaseInfo*>(func));
+          func = nullptr;
+        }
+      }
+    }
   } else if (GI_IS_INTERFACE_INFO(typeInfo)) {
     func = gi_interface_info_find_method(reinterpret_cast<GIInterfaceInfo*>(typeInfo), method.c_str());
   } else if (GI_IS_STRUCT_INFO(typeInfo)) {
@@ -1331,7 +1463,8 @@ Napi::Value CallStaticMethod(const Napi::CallbackInfo& info) {
         .ThrowAsJavaScriptException();
     return env.Null();
   }
-  if (gi_callable_info_is_method(reinterpret_cast<GICallableInfo*>(func))) {
+  const bool isMethod = gi_callable_info_is_method(reinterpret_cast<GICallableInfo*>(func));
+  if (isMethod && classInstance == nullptr) {
     gi_base_info_unref(func);
     g_object_unref(repo);
     Napi::TypeError::New(env, ns + "." + tn + "." + method +
@@ -1339,7 +1472,10 @@ Napi::Value CallStaticMethod(const Napi::CallbackInfo& info) {
         .ThrowAsJavaScriptException();
     return env.Null();
   }
-  Napi::Value result = InvokeFunctionInfo(env, func, nullptr, args, ns + "." + tn + "." + method);
+  // A class struct may also declare plain functions (no instance); only the
+  // is_method ones take the class.
+  Napi::Value result = InvokeFunctionInfo(env, func, isMethod ? classInstance : nullptr, args,
+                                          ns + "." + tn + "." + method);
   gi_base_info_unref(func);
   g_object_unref(repo);
   return result;