begin work on proxied native objects, and also implementing getters/setters for native props in custom classes and more

Author: DjDeveloperr

bench/main.js

@@ -1,39 +1,14 @@
 import "objc";
 import { bench, run } from "mitata";
 
-{
-  const arr = NSArray.array();
-
-  let total = 0;
-  let n = 1e6;
-
-  for (let i = 0; i < n; i++) {
-    const start = performance.now();
-    arr.count;
-    total += performance.now() - start;
-  }
-
-  console.log("ns/iter:", total * 1e6 / n);
-}
-
 const arr = NSMutableArray.arrayWithCapacity(100);
 
-const arr2 = new Proxy(arr, {
-  get: (target, prop) => {
-    return target[prop];
-  },
-});
-
 bench("noop", () => {});
 
 bench("[arr count] (dynamic, ffi)", () => {
   arr.count;
 });
 
-bench("[arr count] (dynamic, proxy)", () => {
-  arr2.count;
-});
-
 await run({
   avg: true, // enable/disable avg column (default: true)
   json: false, // enable/disable json output (default: false)

examples/foundation.js

@@ -20,3 +20,9 @@ const ref2 = new interop.Reference(interop.types.uint32, backing);
 console.log(ref2, ref2.value);
 ref2.value = 3;
 console.log(ref2, ref2.value);
+
+const arr = NSMutableArray.arrayWithCapacity(1);
+// console.log(arr[0]);
+arr.insertObjectAtIndex(NSObject.new(), 0);
+console.log(arr[0]);
+console.log(arr);

include/ClassMember.h

@@ -22,6 +22,7 @@ class MethodDescriptor {
 
   MDSectionOffset signatureOffset;
   std::string encoding;
+  bool isProperty = false;
 
   MethodDescriptor() {}
 
@@ -67,7 +68,10 @@ class ObjCClassMember {
         methodOrGetter(MethodDescriptor(getterSelector, getterOffset)),
         setter(MethodDescriptor(setterSelector, setterOffset)),
         returnOwned((flags & metagen::mdMemberReturnOwned) != 0),
-        classMethod((flags & metagen::mdMemberStatic) != 0) {}
+        classMethod((flags & metagen::mdMemberStatic) != 0) {
+    methodOrGetter.isProperty = true;
+    setter.isProperty = true;
+  }
 
   ObjCBridgeState *bridgeState;
   MethodDescriptor methodOrGetter;

include/Closure.h

@@ -19,13 +19,15 @@ class Closure {
   Closure(std::string typeEncoding, bool isBlock);
   Closure(MDMetadataReader *reader, MDSectionOffset offset,
           bool isBlock = false, std::string *encoding = nullptr,
-          bool isMethod = false);
+          bool isMethod = false, bool isGetter = false, bool isSetter = false);
 
   ~Closure();
 
   napi_env env;
   napi_ref thisConstructor;
   napi_ref func = nullptr;
+  bool isGetter = false;
+  bool isSetter = false;
   std::string propertyName;
   napi_threadsafe_function tsfn;
 

include/ObjCBridge.h

@@ -71,6 +71,9 @@ class ObjCBridgeState {
   MethodCif *getMethodCif(napi_env env, Method method);
   MethodCif *getMethodCif(napi_env env, MDSectionOffset offset);
 
+  napi_value proxyNativeObject(napi_env env, napi_value object,
+                               bool isArray = false);
+
   napi_value getObject(napi_env env, id object, napi_value constructor,
                        ObjectOwnership ownership = kUnownedObject);
   napi_value getObject(napi_env env, id object,
@@ -111,6 +114,7 @@ class ObjCBridgeState {
 
   napi_ref pointerClass;
   napi_ref referenceClass;
+  napi_ref createNativeProxy;
 
   std::unordered_map<MDSectionOffset, ObjCClass *> classes;
   std::unordered_map<MDSectionOffset, ObjCProtocol *> protocols;

include/Object.h

@@ -0,0 +1,12 @@
+#ifndef OBJECT_H
+#define OBJECT_H
+
+#include "ObjCBridge.h"
+
+namespace objc_bridge {
+
+void initProxyFactory(napi_env env, ObjCBridgeState *bridgeState);
+
+} // namespace objc_bridge
+
+#endif /* OBJECT_H */

metadata/metadata.ios.nsmd

@@ -0,0 +1,19 @@
+#ifndef PERFORMANCE_H
+#define PERFORMANCE_H
+
+#include "js_native_api.h"
+
+namespace charon {
+
+class Performance {
+public:
+  static void init(napi_env env);
+
+  static napi_value constructor(napi_env env, napi_callback_info cbinfo);
+
+  static napi_value now(napi_env env, napi_callback_info cbinfo);
+};
+
+} // namespace charon
+
+#endif // PERFORMANCE_H

runtime/include/Performance.h

@@ -0,0 +1,66 @@
+#include "Performance.h"
+#include "mach/mach_time.h"
+
+namespace charon {
+
+void Performance::init(napi_env env) {
+  napi_value global, Performance, performance;
+
+  napi_get_global(env, &global);
+
+  const napi_property_descriptor properties[] = {
+      {
+          .utf8name = "now",
+          .name = nullptr,
+          .method = now,
+          .getter = nullptr,
+          .setter = nullptr,
+          .value = nullptr,
+          .attributes = napi_default,
+          .data = nullptr,
+      },
+  };
+
+  napi_define_class(env, "Performance", NAPI_AUTO_LENGTH,
+                    Performance::constructor, nullptr, 1, properties,
+                    &Performance);
+
+  napi_new_instance(env, Performance, 0, nullptr, &performance);
+
+  const napi_property_descriptor globalProperties[] = {
+      {
+          .utf8name = "performance",
+          .name = nullptr,
+          .method = nullptr,
+          .getter = nullptr,
+          .setter = nullptr,
+          .value = performance,
+          .attributes = napi_default,
+          .data = nullptr,
+      },
+  };
+
+  napi_define_properties(env, global, 1, globalProperties);
+}
+
+napi_value Performance::constructor(napi_env env, napi_callback_info cbinfo) {
+  napi_value thisArg;
+  napi_get_cb_info(env, cbinfo, nullptr, nullptr, &thisArg, nullptr);
+
+  return thisArg;
+}
+
+napi_value Performance::now(napi_env env, napi_callback_info cbinfo) {
+  uint64_t time = mach_absolute_time();
+  mach_timebase_info_data_t timebase;
+  mach_timebase_info(&timebase);
+  double nanoseconds =
+      (double)time * (double)timebase.numer / (double)timebase.denom;
+  double milliseconds = nanoseconds / 1000000.0;
+
+  napi_value result;
+  napi_create_double(env, milliseconds, &result);
+  return result;
+}
+
+} // namespace charon

runtime/src/Performance.cpp

@@ -1,5 +1,6 @@
 #include "Runtime.h"
 #include "Console.h"
+#include "Performance.h"
 #include <iostream>
 
 namespace charon {
@@ -23,6 +24,7 @@ Runtime::Runtime() {
   runtime->createNapiEnv(&env);
 
   Console::init(env);
+  Performance::init(env);
 
   const char *metadata_path = std::getenv("METADATA_PATH");
   objc_bridge_init(env, metadata_path);