Rename ObjCBridgeData to ObjCBridgeState, BridgedClass to ObjCClass, BridgedMethod to ObjCClassMethod, improve memory management

Author: DjDeveloperr

include/Class.h

@@ -2,11 +2,12 @@
 #define BRIDGED_CLASS_H
 
 #include "MetadataReader.h"
+#include "NativeCall.h"
 #include "node_api_util.h"
 #include "objc/message.h"
 #include "objc/runtime.h"
-#include <set>
 #include <string>
+#include <unordered_set>
 
 using namespace metagen;
 
@@ -16,21 +17,22 @@ NAPI_FUNCTION(registerClass);
 NAPI_FUNCTION(import);
 NAPI_FUNCTION(classGetter);
 
-class BridgedClass {
+class ObjCClass {
 public:
   MDSectionOffset metadataOffset;
   std::string name;
   Class nativeClass;
 
-  BridgedClass *superclass;
+  ObjCClass *superclass;
+  std::vector<std::shared_ptr<ObjCClassMember>> members;
 
   napi_env env;
   napi_ref constructor;
   napi_ref prototype;
 
-  BridgedClass() {}
-  BridgedClass(napi_env env, MDSectionOffset offset);
-  ~BridgedClass();
+  ObjCClass() {}
+  ObjCClass(napi_env env, MDSectionOffset offset);
+  ~ObjCClass();
 };
 
 } // namespace objc_bridge

include/NativeCall.h

@@ -1,7 +1,7 @@
 #ifndef BRIDGED_METHOD_H
 #define BRIDGED_METHOD_H
 
-#include "ObjCBridge.h"
+#include "MethodCif.h"
 #include "objc/runtime.h"
 
 namespace objc_bridge {
@@ -11,9 +11,11 @@ napi_value JS_BridgedMethod(napi_env env, napi_callback_info cbinfo);
 napi_value JS_BridgedGetter(napi_env env, napi_callback_info cbinfo);
 napi_value JS_BridgedSetter(napi_env env, napi_callback_info cbinfo);
 
-class BridgedMethod {
+class ObjCBridgeState;
+
+class ObjCClassMember {
 public:
-  ObjCBridgeData *bridgeData;
+  ObjCBridgeState *bridgeState;
   // Can be either method selector or property getter selector
   SEL selector;
   SEL setterSelector;

include/ObjCBridge.h

@@ -42,18 +42,18 @@ typedef enum ObjectOwnership {
   kBorrowedObject,
 } ObjectOwnership;
 
-class ObjCBridgeData {
+class ObjCBridgeState {
 public:
-  ObjCBridgeData(napi_env env, const char *metadata_path = nullptr);
-  ~ObjCBridgeData();
+  ObjCBridgeState(napi_env env, const char *metadata_path = nullptr);
+  ~ObjCBridgeState();
 
-  static inline ObjCBridgeData *InstanceData(napi_env env) {
-    ObjCBridgeData *bridgeData;
-    napi_status status = napi_get_instance_data(env, (void **)&bridgeData);
+  static inline ObjCBridgeState *InstanceData(napi_env env) {
+    ObjCBridgeState *bridgeState;
+    napi_status status = napi_get_instance_data(env, (void **)&bridgeState);
     if (status != napi_ok) {
       return nullptr;
     }
-    return bridgeData;
+    return bridgeState;
   }
 
   void registerVarGlobals(napi_env env, napi_value global);
@@ -64,7 +64,7 @@ class ObjCBridgeData {
   void registerClassGlobals(napi_env env, napi_value global);
   void registerProtocolGlobals(napi_env env, napi_value global);
 
-  BridgedClass *getClass(napi_env env, MDSectionOffset offset);
+  ObjCClass *getClass(napi_env env, MDSectionOffset offset);
 
   BridgedProtocol *getProtocol(napi_env env, MDSectionOffset offset);
 
@@ -114,9 +114,9 @@ class ObjCBridgeData {
   napi_ref pointerClass;
   napi_ref referenceClass;
 
-  std::unordered_map<MDSectionOffset, BridgedClass *> classes;
+  std::unordered_map<MDSectionOffset, ObjCClass *> classes;
   std::unordered_map<MDSectionOffset, BridgedProtocol *> protocols;
-  std::unordered_map<Class, BridgedClass *> classesByPointer;
+  std::unordered_map<Class, ObjCClass *> classesByPointer;
   std::unordered_map<Class, MDSectionOffset> mdClassesByPointer;
   std::unordered_map<Protocol *, MDSectionOffset> mdProtocolsByPointer;
   std::unordered_map<Class, napi_ref> constructorsByPointer;

src/Block.mm

@@ -64,8 +64,8 @@ id registerBlock(napi_env env, Closure *closure, napi_value callback) {
   }
   closure->func = ref;
 
-  auto bridgeData = ObjCBridgeData::InstanceData(env);
-  if (napiSupportsThreadsafeFunctions(bridgeData->self_dl)) {
+  auto bridgeState = ObjCBridgeState::InstanceData(env);
+  if (napiSupportsThreadsafeFunctions(bridgeState->self_dl)) {
     napi_value workName;
     napi_create_string_utf8(env, "Block", NAPI_AUTO_LENGTH, &workName);
     napi_create_threadsafe_function(env, callback, nullptr, workName, 0, 1,

src/CFunction.mm

@@ -4,7 +4,7 @@
 
 namespace objc_bridge {
 
-void ObjCBridgeData::registerFunctionGlobals(napi_env env, napi_value global) {
+void ObjCBridgeState::registerFunctionGlobals(napi_env env, napi_value global) {
   MDSectionOffset offset = metadata->functionsOffset;
   while (offset < metadata->protocolsOffset) {
     MDSectionOffset originalOffset = offset;
@@ -28,7 +28,7 @@
   }
 }
 
-CFunction *ObjCBridgeData::getCFunction(napi_env env, MDSectionOffset offset) {
+CFunction *ObjCBridgeState::getCFunction(napi_env env, MDSectionOffset offset) {
   auto cached = cFunctionCache.find(offset);
   if (cached != cFunctionCache.end()) {
     return cached->second;

src/Class.mm

@@ -14,7 +14,7 @@
 
 namespace objc_bridge {
 
-void ObjCBridgeData::registerClassGlobals(napi_env env, napi_value global) {
+void ObjCBridgeState::registerClassGlobals(napi_env env, napi_value global) {
   MDSectionOffset offset = metadata->classesOffset;
   while (offset < metadata->structsOffset) {
     MDSectionOffset originalOffset = offset;
@@ -89,22 +89,22 @@
     return func;
   }
 
-  auto bridgeData = ObjCBridgeData::InstanceData(env);
-  bridgeData->registerClass(env, argv[0]);
+  auto bridgeState = ObjCBridgeState::InstanceData(env);
+  bridgeState->registerClass(env, argv[0]);
   return nullptr;
 }
 
 char class_name[256];
 
 // Get a Bridged Class by metadata offset, creating it if it doesn't exist.
-// This is used to cache BridgedClass instances.
-BridgedClass *ObjCBridgeData::getClass(napi_env env, MDSectionOffset offset) {
+// This is used to cache ObjCClass instances.
+ObjCClass *ObjCBridgeState::getClass(napi_env env, MDSectionOffset offset) {
   auto find = this->classes[offset];
   if (find != nullptr) {
     return find;
   }
 
-  auto bridgedClass = new BridgedClass(env, offset);
+  auto bridgedClass = new ObjCClass(env, offset);
   this->classes[offset] = bridgedClass;
 
   return bridgedClass;
@@ -146,18 +146,18 @@
   void *data;
   napi_get_cb_info(env, cbinfo, nullptr, nullptr, nullptr, &data);
   MDSectionOffset offset = (MDSectionOffset)((size_t)data);
-  auto bridgeData = ObjCBridgeData::InstanceData(env);
+  auto bridgeState = ObjCBridgeState::InstanceData(env);
 
-  auto cached = bridgeData->mdValueCache[offset];
+  auto cached = bridgeState->mdValueCache[offset];
   if (cached != nullptr) {
     return get_ref_value(env, cached);
   }
 
-  // std::string name = bridgeData->metadata->getString(offset);
-  auto cls = bridgeData->getClass(env, offset);
+  // std::string name = bridgeState->metadata->getString(offset);
+  auto cls = bridgeState->getClass(env, offset);
 
   if (cls != nullptr) {
-    bridgeData->mdValueCache[offset] = cls->constructor;
+    bridgeState->mdValueCache[offset] = cls->constructor;
   } else {
     return nullptr;
   }
@@ -204,8 +204,8 @@
   napi_get_cb_info(env, cbinfo, nil, nil, &jsThis, &data);
   id self;
   napi_unwrap(env, jsThis, (void **)&self);
-  auto bridgeData = ObjCBridgeData::InstanceData(env);
-  bridgeData->unregisterObject(self);
+  auto bridgeState = ObjCBridgeState::InstanceData(env);
+  bridgeState->unregisterObject(self);
   return nullptr;
 }
 
@@ -220,14 +220,14 @@
 // extended by a JS class.
 // Every Bridged Class extends the NativeObject class.
 
-BridgedClass::BridgedClass(napi_env env, MDSectionOffset offset) {
+ObjCClass::ObjCClass(napi_env env, MDSectionOffset offset) {
   NAPI_PREAMBLE
 
   this->env = env;
 
   metadataOffset = offset;
 
-  auto bridgeData = ObjCBridgeData::InstanceData(env);
+  auto bridgeState = ObjCBridgeState::InstanceData(env);
 
   bool isNativeObject = offset == MD_SECTION_OFFSET_NULL;
 
@@ -239,20 +239,20 @@
     name = NativeObjectName;
     nativeClass = nil;
   } else {
-    auto nameOffset = bridgeData->metadata->getOffset(offset);
+    auto nameOffset = bridgeState->metadata->getOffset(offset);
     offset += sizeof(MDSectionOffset);
     bool hasProtocols = (nameOffset & mdSectionOffsetNext) != 0;
     nameOffset &= ~mdSectionOffsetNext;
-    name = bridgeData->metadata->resolveString(nameOffset);
+    name = bridgeState->metadata->resolveString(nameOffset);
     while (hasProtocols) {
-      auto protocolOffset = bridgeData->metadata->getOffset(offset);
+      auto protocolOffset = bridgeState->metadata->getOffset(offset);
       offset += sizeof(MDSectionOffset);
       hasProtocols = (protocolOffset & mdSectionOffsetNext) != 0;
       protocolOffset &= ~mdSectionOffsetNext;
       if (protocolOffset != MD_SECTION_OFFSET_NULL)
         protocolOffsets.push_back(protocolOffset);
     }
-    superClassOffset = bridgeData->metadata->getOffset(offset);
+    superClassOffset = bridgeState->metadata->getOffset(offset);
     hasMembers = (superClassOffset & mdSectionOffsetNext) != 0;
     superClassOffset &= ~mdSectionOffsetNext;
     offset += sizeof(MDSectionOffset);
@@ -277,20 +277,20 @@
   // exists.
   if (!isNativeObject) {
     for (auto protocolOffset : protocolOffsets) {
-      auto protocol = bridgeData->getProtocol(
-          env, protocolOffset + bridgeData->metadata->protocolsOffset);
+      auto protocol = bridgeState->getProtocol(
+          env, protocolOffset + bridgeState->metadata->protocolsOffset);
       if (protocol == nil)
         continue;
       defineProtocolMembers(env, protocol->membersOffset, constructor);
     }
 
     if (superClassOffset != MD_SECTION_OFFSET_NULL) {
-      superClassOffset += bridgeData->metadata->classesOffset;
+      superClassOffset += bridgeState->metadata->classesOffset;
     }
 
     // If class offset is 0, it means that the class doesn't have a super class.
     // But we just inherit NativeObject class in that case.
-    superclass = bridgeData->getClass(env, superClassOffset);
+    superclass = bridgeState->getClass(env, superClassOffset);
     if (superclass != nil) {
       superConstructor = get_ref_value(env, superclass->constructor);
       superPrototype = get_ref_value(env, superclass->prototype);
@@ -334,14 +334,14 @@
     return;
   }
 
-  bridgeData->classesByPointer[nativeClass] = this;
+  bridgeState->classesByPointer[nativeClass] = this;
 
   if (!hasMembers)
     return;
 
   bool next = true;
   while (next) {
-    auto flags = bridgeData->metadata->getMemberFlag(offset);
+    auto flags = bridgeState->metadata->getMemberFlag(offset);
     next = (flags & mdMemberNext) != 0;
     offset += sizeof(flags);
 
@@ -354,38 +354,39 @@
 
     if ((flags & mdMemberProperty) != 0) {
       bool readonly = (flags & mdMemberReadonly) != 0;
-      auto name = bridgeData->metadata->getString(offset);
+      auto name = bridgeState->metadata->getString(offset);
       offset += sizeof(MDSectionOffset); // name
 
       MDSectionOffset getterSignature, setterSignature;
 
-      auto getterSelector = bridgeData->metadata->getString(offset);
+      auto getterSelector = bridgeState->metadata->getString(offset);
       offset += sizeof(MDSectionOffset); // getterSelector
 
-      getterSignature = bridgeData->metadata->getOffset(offset);
+      getterSignature = bridgeState->metadata->getOffset(offset);
       offset += sizeof(MDSectionOffset); // getterSignature
 
       const char *setterSelector = nullptr;
       if (!readonly) {
-        setterSelector = bridgeData->metadata->getString(offset);
+        setterSelector = bridgeState->metadata->getString(offset);
         offset += sizeof(MDSectionOffset); // setterSelector
 
-        setterSignature = bridgeData->metadata->getOffset(offset);
+        setterSignature = bridgeState->metadata->getOffset(offset);
         offset += sizeof(MDSectionOffset); // setterSignature
       }
 
-      auto prop = new BridgedMethod();
-      prop->bridgeData = bridgeData;
+      std::shared_ptr<ObjCClassMember> prop =
+          std::make_shared<ObjCClassMember>();
+      prop->bridgeState = bridgeState;
       prop->classMethod = (flags & mdMemberStatic) != 0;
       prop->selector = sel_registerName(getterSelector);
       prop->setterSelector =
           setterSelector == nullptr ? nil : sel_registerName(setterSelector);
       prop->signature =
-          getterSignature + bridgeData->metadata->signaturesOffset;
+          getterSignature + bridgeState->metadata->signaturesOffset;
       prop->setterSignature =
           setterSelector == nullptr
               ? 0
-              : setterSignature + bridgeData->metadata->signaturesOffset;
+              : setterSignature + bridgeState->metadata->signaturesOffset;
 
       napi_property_descriptor property = {
           .utf8name = name,
@@ -396,14 +397,14 @@
           .value = nil,
           .attributes =
               (napi_property_attributes)(napi_configurable | napi_enumerable),
-          .data = prop,
+          .data = members.emplace_back(prop).get(),
       };
 
       napi_define_properties(env, jsObject, 1, &property);
     } else {
-      auto selector = bridgeData->metadata->getString(offset);
+      auto selector = bridgeState->metadata->getString(offset);
       offset += sizeof(MDSectionOffset); // selector
-      auto signature = bridgeData->metadata->getOffset(offset);
+      auto signature = bridgeState->metadata->getOffset(offset);
       offset += sizeof(MDSectionOffset); // signature
 
       auto name = jsifySelector(selector);
@@ -414,11 +415,12 @@
         continue;
       }
 
-      auto method = new BridgedMethod();
-      method->bridgeData = bridgeData;
+      std::shared_ptr<ObjCClassMember> method =
+          std::make_shared<ObjCClassMember>();
+      method->bridgeState = bridgeState;
       method->classMethod = (flags & mdMemberStatic) != 0;
       method->selector = sel_registerName(selector);
-      method->signature = signature + bridgeData->metadata->signaturesOffset;
+      method->signature = signature + bridgeState->metadata->signaturesOffset;
       method->returnOwned = (flags & mdMemberReturnOwned) != 0;
 
       napi_property_descriptor property = {
@@ -431,15 +433,15 @@
           .attributes =
               (napi_property_attributes)(napi_configurable | napi_writable |
                                          napi_enumerable),
-          .data = method,
+          .data = members.emplace_back(method).get(),
       };
 
       napi_define_properties(env, jsObject, 1, &property);
     }
   }
 }
 
-BridgedClass::~BridgedClass() {
+ObjCClass::~ObjCClass() {
   napi_delete_reference(env, constructor);
   napi_delete_reference(env, prototype);
 }