fix: correctly convert function and block pointers in arguments to callable functions from JS

Author: DjDeveloperr

CMakeLists.txt

@@ -90,7 +90,7 @@ set(LIB_SOURCE_FILES
   src/Class.mm
   src/Closure.mm
   src/ClassMember.mm
-  src/MethodCif.mm
+  src/Cif.mm
   src/TypeConv.mm
   src/Util.mm
   src/Struct.mm

examples/webview.js

@@ -51,9 +51,10 @@ export class ApplicationDelegate extends NSObject {
 
 /**
  * @implements {WKUIDelegate}
+ * @implements {WKNavigationDelegate}
  */
 export class ViewController extends NSViewController {
-  static ObjCProtocols = [WKUIDelegate];
+  static ObjCProtocols = [WKUIDelegate, WKNavigationDelegate];
 
   static {
     NativeClass(this);
@@ -74,6 +75,7 @@ export class ViewController extends NSViewController {
       config,
     );
     view.UIDelegate = this;
+    view.navigationDelegate = this;
     this.view = view;
     this.webview = view;
   }
@@ -93,6 +95,19 @@ export class ViewController extends NSViewController {
     const request = NSURLRequest.requestWithURL(url);
     if (this.webview) this.webview.loadRequest(request);
   }
+
+  /**
+   * @param {WKWebView} _webView
+   * @param {WKNavigationAction} _navigationAction
+   * @param {(p1: interop.Enum<typeof WKNavigationActionPolicy>) => void} decisionHandler
+   */
+  webViewDecidePolicyForNavigationActionDecisionHandler(
+    _webView,
+    _navigationAction,
+    decisionHandler,
+  ) {
+    decisionHandler(WKNavigationActionPolicy.Allow);
+  }
 }
 
 const NSApp = NSApplication.sharedApplication;

include/Block.h

@@ -1,12 +1,26 @@
 #ifndef BLOCK_H
 #define BLOCK_H
 
+#include "Cif.h"
 #include "Closure.h"
 #include "node_api_util.h"
 #include <cstdlib>
 
 namespace objc_bridge {
 
+class FunctionPointer {
+public:
+  void *function;
+  metagen::MDSectionOffset offset;
+  Cif *cif;
+
+  static napi_value wrap(napi_env env, void *function, metagen::MDSectionOffset offset, bool isBlock);
+  static void finalize(napi_env env, void *finalize_data, void *finalize_hint);
+
+  static napi_value jsCallAsCFunction(napi_env env, napi_callback_info cbinfo);
+  static napi_value jsCallAsBlock(napi_env env, napi_callback_info cbinfo);
+};
+
 id registerBlock(napi_env env, Closure *closure, napi_value callback);
 
 NAPI_FUNCTION(registerBlock);

include/CFunction.h

@@ -1,19 +1,19 @@
 #ifndef C_FUNCTION_H
 #define C_FUNCTION_H
 
-#include "MethodCif.h"
+#include "Cif.h"
 
 namespace objc_bridge {
 
 class CFunction {
 public:
-  static napi_value JSCall(napi_env env, napi_callback_info cbinfo);
+  static napi_value jsCall(napi_env env, napi_callback_info cbinfo);
 
   CFunction(void *fnptr) : fnptr(fnptr) {}
   ~CFunction();
 
   void *fnptr;
-  MethodCif *cif = nullptr;
+  Cif *cif = nullptr;
 };
 
 } // namespace objc_bridge

include/MethodCif.h renamed to include/Cif.h

@@ -10,7 +10,7 @@
 
 namespace objc_bridge {
 
-class MethodCif {
+class Cif {
 public:
   ffi_cif cif;
   unsigned int argc;
@@ -28,9 +28,9 @@ class MethodCif {
   bool shouldFreeAny;
   bool *shouldFree;
 
-  MethodCif(napi_env env, std::string typeEncoding);
-  MethodCif(napi_env env, MDMetadataReader *reader, MDSectionOffset offset,
-            bool isMethod = false);
+  Cif(napi_env env, std::string typeEncoding);
+  Cif(napi_env env, MDMetadataReader *reader, MDSectionOffset offset,
+            bool isMethod = false, bool isBlock = false);
 };
 
 } // namespace objc_bridge

include/ClassMember.h

@@ -1,7 +1,7 @@
 #ifndef BRIDGED_METHOD_H
 #define BRIDGED_METHOD_H
 
-#include "MethodCif.h"
+#include "Cif.h"
 #include "objc/runtime.h"
 #include <iostream>
 
@@ -50,10 +50,10 @@ class ObjCClassMember {
   static void defineMembers(napi_env env, ObjCClassMemberMap &memberMap,
                             MDSectionOffset offset, napi_value constructor);
 
-  static napi_value JSCall(napi_env env, napi_callback_info cbinfo);
-  static napi_value JSCallInit(napi_env env, napi_callback_info cbinfo);
-  static napi_value JSGetter(napi_env env, napi_callback_info cbinfo);
-  static napi_value JSSetter(napi_env env, napi_callback_info cbinfo);
+  static napi_value jsCall(napi_env env, napi_callback_info cbinfo);
+  static napi_value jsCallInit(napi_env env, napi_callback_info cbinfo);
+  static napi_value jsGetter(napi_env env, napi_callback_info cbinfo);
+  static napi_value jsSetter(napi_env env, napi_callback_info cbinfo);
 
   ObjCClassMember(ObjCBridgeState *bridgeState, SEL selector,
                   MDSectionOffset offset, MDMemberFlag flags)
@@ -77,8 +77,8 @@ class ObjCClassMember {
   ObjCBridgeState *bridgeState;
   MethodDescriptor methodOrGetter;
   MethodDescriptor setter;
-  MethodCif *methodCif = nullptr;
-  MethodCif *setterMethodCif = nullptr;
+  Cif *cif = nullptr;
+  Cif *setterCif = nullptr;
   bool returnOwned;
   bool classMethod;
 };

include/ObjCBridge.h

@@ -5,7 +5,7 @@
 #include "CFunction.h"
 #include "Class.h"
 #include "MetadataReader.h"
-#include "MethodCif.h"
+#include "Cif.h"
 #include "Protocol.h"
 #include "Struct.h"
 #include "TypeConv.h"
@@ -66,8 +66,10 @@ class ObjCBridgeState {
 
   ObjCProtocol *getProtocol(napi_env env, MDSectionOffset offset);
 
-  MethodCif *getMethodCif(napi_env env, Method method);
-  MethodCif *getMethodCif(napi_env env, MDSectionOffset offset);
+  Cif *getMethodCif(napi_env env, Method method);
+  Cif *getMethodCif(napi_env env, MDSectionOffset offset);
+  Cif *getBlockCif(napi_env env, MDSectionOffset offset);
+  Cif *getCFunctionCif(napi_env env, MDSectionOffset offset);
 
   napi_value proxyNativeObject(napi_env env, napi_value object,
                                id nativeObject);
@@ -123,11 +125,12 @@ class ObjCBridgeState {
   std::unordered_map<Protocol *, MDSectionOffset> mdProtocolsByPointer;
   std::unordered_map<Class, napi_ref> constructorsByPointer;
 
-  std::unordered_map<std::string, MethodCif *> methodCifs;
+  std::unordered_map<std::string, Cif *> cifs;
   std::unordered_map<MDSectionOffset, napi_ref> mdValueCache;
   std::unordered_map<MDSectionOffset, CFunction *> cFunctionCache;
-  std::unordered_map<MDSectionOffset, MethodCif *> mdFunctionSignatureCache;
-  std::unordered_map<MDSectionOffset, MethodCif *> mdMethodSignatureCache;
+  std::unordered_map<MDSectionOffset, Cif *> mdFunctionSignatureCache;
+  std::unordered_map<MDSectionOffset, Cif *> mdMethodSignatureCache;
+  std::unordered_map<MDSectionOffset, Cif *> mdBlockSignatureCache;
   std::unordered_map<std::string, MDSectionOffset> structOffsets;
   std::unordered_map<std::string, MDSectionOffset> unionOffsets;
   // std::unordered_map<std::string, MDSectionOffset> protocolOffsets;

include/Protocol.h

@@ -15,7 +15,7 @@ NAPI_FUNCTION(protocolGetter);
 
 class ObjCProtocol {
 public:
-  static napi_value JSConstructor(napi_env env, napi_callback_info cbinfo);
+  static napi_value jsConstructor(napi_env env, napi_callback_info cbinfo);
 
   ObjCProtocol(napi_env env, MDSectionOffset offset);
   ~ObjCProtocol();

src/Block.mm

@@ -1,5 +1,7 @@
 #include "Block.h"
+#include "Interop.h"
 #include "ObjCBridge.h"
+#include "js_native_api.h"
 #include "node_api_util.h"
 #include "objc/runtime.h"
 #import <Foundation/Foundation.h>
@@ -96,4 +98,118 @@ id registerBlock(napi_env env, Closure *closure, napi_value callback) {
   return callback;
 }
 
+napi_value FunctionPointer::wrap(napi_env env, void *function,
+                                 metagen::MDSectionOffset offset,
+                                 bool isBlock) {
+  FunctionPointer *ref = new FunctionPointer();
+  ref->function = function;
+  ref->offset = offset;
+
+  ObjCBridgeState *bridgeState = ObjCBridgeState::InstanceData(env);
+
+  if (isBlock) {
+    ref->cif = bridgeState->getBlockCif(env, offset);
+  } else {
+    ref->cif = bridgeState->getCFunctionCif(env, offset);
+  }
+
+  napi_value result;
+  napi_create_function(
+      env, isBlock ? "objcBlockWrapper" : "cFunctionWrapper", NAPI_AUTO_LENGTH,
+      isBlock ? jsCallAsBlock : jsCallAsCFunction, ref, &result);
+
+  napi_ref jsRef;
+  napi_add_finalizer(env, result, ref, FunctionPointer::finalize, nullptr,
+                     &jsRef);
+
+  return result;
+}
+
+void FunctionPointer::finalize(napi_env env, void *finalize_data,
+                               void *finalize_hint) {
+  auto ref = (FunctionPointer *)finalize_data;
+  delete ref;
+}
+
+napi_value FunctionPointer::jsCallAsCFunction(napi_env env,
+                                              napi_callback_info cbinfo) {
+  FunctionPointer *ref;
+
+  napi_get_cb_info(env, cbinfo, nullptr, nullptr, nullptr, (void **)&ref);
+
+  auto cif = ref->cif;
+
+  size_t argc = cif->argc;
+  napi_get_cb_info(env, cbinfo, &argc, cif->argv, nullptr, nullptr);
+
+  void *avalues[cif->argc];
+  void *rvalue = cif->rvalue;
+
+  bool shouldFreeAny = false;
+  bool shouldFree[cif->argc];
+
+  if (cif->argc > 0) {
+    for (unsigned int i = 0; i < cif->argc; i++) {
+      shouldFree[i] = false;
+      avalues[i] = cif->avalues[i];
+      cif->argTypes[i]->toNative(env, cif->argv[i], avalues[i], &shouldFree[i],
+                                 &shouldFreeAny);
+    }
+  }
+
+  ffi_call(&cif->cif, FFI_FN(ref->function), rvalue, avalues);
+
+  if (shouldFreeAny) {
+    for (unsigned int i = 0; i < cif->argc; i++) {
+      if (shouldFree[i]) {
+        cif->argTypes[i]->free(env, *((void **)avalues[i]));
+      }
+    }
+  }
+
+  return cif->returnType->toJS(env, rvalue);
+}
+
+napi_value FunctionPointer::jsCallAsBlock(napi_env env,
+                                          napi_callback_info cbinfo) {
+  FunctionPointer *ref;
+
+  napi_get_cb_info(env, cbinfo, nullptr, nullptr, nullptr, (void **)&ref);
+
+  Block_literal_1 *block = (Block_literal_1 *)ref->function;
+  auto cif = ref->cif;
+
+  size_t argc = cif->argc;
+  napi_get_cb_info(env, cbinfo, &argc, cif->argv, nullptr, nullptr);
+
+  void *avalues[cif->cif.nargs];
+  void *rvalue = cif->rvalue;
+
+  bool shouldFreeAny = false;
+  bool shouldFree[cif->argc];
+
+  avalues[0] = &block;
+
+  if (cif->argc > 0) {
+    for (unsigned int i = 0; i < cif->argc; i++) {
+      shouldFree[i] = false;
+      avalues[i + 1] = cif->avalues[i];
+      cif->argTypes[i]->toNative(env, cif->argv[i], avalues[i + 1],
+                                 &shouldFree[i], &shouldFreeAny);
+    }
+  }
+
+  ffi_call(&cif->cif, FFI_FN(block->invoke), rvalue, avalues);
+
+  if (shouldFreeAny) {
+    for (unsigned int i = 0; i < cif->argc; i++) {
+      if (shouldFree[i]) {
+        cif->argTypes[i]->free(env, *((void **)avalues[i + 1]));
+      }
+    }
+  }
+
+  return cif->returnType->toJS(env, rvalue);
+}
+
 } // namespace objc_bridge

src/CFunction.mm

@@ -21,7 +21,7 @@
         .setter = nullptr,
         .value = nullptr,
         .data = (void *)((size_t)originalOffset),
-        .method = CFunction::JSCall,
+        .method = CFunction::jsCall,
     };
 
     napi_define_properties(env, global, 1, &prop);
@@ -36,23 +36,15 @@
 
   auto sigOffset = metadata->signaturesOffset +
                    metadata->getOffset(offset + sizeof(MDSectionOffset));
-  auto cachedCif = mdFunctionSignatureCache.find(sigOffset);
 
   auto cFunction = new CFunction(dlsym(self_dl, metadata->getString(offset)));
+  cFunction->cif = getCFunctionCif(env, sigOffset);
   cFunctionCache[offset] = cFunction;
 
-  if (cachedCif != mdFunctionSignatureCache.end()) {
-    cFunction->cif = cachedCif->second;
-  } else {
-    auto cif = new MethodCif(env, metadata, sigOffset);
-    cFunction->cif = cif;
-    mdFunctionSignatureCache[sigOffset] = cif;
-  }
-
   return cFunction;
 }
 
-napi_value CFunction::JSCall(napi_env env, napi_callback_info cbinfo) {
+napi_value CFunction::jsCall(napi_env env, napi_callback_info cbinfo) {
   void *_offset;
 
   napi_get_cb_info(env, cbinfo, nullptr, nullptr, nullptr, &_offset);