perf(ffi): cache prepared ObjC invocation per arg count in method host fn

Parse the metadata/ObjC signatures once per (method, arg count) and
reuse the prepared invocation, instead of re-parsing on every call.

Author: DjDeveloperr

NativeScript/ffi/shared/bridge/HostObjects.mm

@@ -1215,51 +1215,69 @@ throw JSError(runtime,
         // through the property interceptor is not).
         if (hasMethodMember(members, property, false)) {
           auto bridge = bridge_;
-          id object = object_;
           std::weak_ptr<NativeApiObjectHostObject> weakSelf =
               shared_from_this();
           std::string memberName = property;
+          // Cache the prepared invocation per argument count so the metadata
+          // and ObjC signatures are parsed once instead of on every call.
+          auto preparedCache = std::make_shared<std::unordered_map<
+              size_t,
+              std::pair<std::string,
+                        std::shared_ptr<NativeApiPreparedObjCInvocation>>>>();
           Value methodFunction = Function::createFromHostFunction(
               runtime, PropNameID::forAscii(runtime, property.c_str()), 0,
-              [bridge, object, weakSelf, memberName](
+              [bridge, weakSelf, memberName, preparedCache](
                   Runtime& runtime, const Value&, const Value* args,
                   size_t count) -> Value {
-                const NativeApiSymbol* symbol =
-                    bridge->findClassForRuntimeClass(object_getClass(object));
-                if (symbol == nullptr) {
-                  throw JSError(
-                      runtime,
-                      "Objective-C metadata is not available for object.");
+                auto self = weakSelf.lock();
+                if (!self || self->object_ == nil) {
+                  throw JSError(runtime,
+                                "Cannot send Objective-C selector to nil.");
                 }
-                const NativeApiMember* selected = selectMethodMember(
-                    bridge->membersForClass(*symbol), memberName, false, count);
-                if (selected == nullptr) {
-                  // NSError-out methods (selector ending in "error:") may be
-                  // called with the trailing error argument omitted.
+                auto cached = preparedCache->find(count);
+                if (cached == preparedCache->end()) {
+                  const NativeApiSymbol* symbol =
+                      bridge->findClassForRuntimeClass(
+                          object_getClass(self->object_));
+                  if (symbol == nullptr) {
+                    throw JSError(
+                        runtime,
+                        "Objective-C metadata is not available for object.");
+                  }
                   const auto& classMembers = bridge->membersForClass(*symbol);
-                  if (const NativeApiMember* withError = selectMethodMember(
-                          classMembers, memberName, false, count + 1)) {
-                    const std::string& sel = withError->selectorName;
-                    if (sel.size() >= 6 &&
-                        sel.compare(sel.size() - 6, 6, "error:") == 0) {
-                      selected = withError;
+                  const NativeApiMember* selected =
+                      selectMethodMember(classMembers, memberName, false, count);
+                  if (selected == nullptr) {
+                    // NSError-out methods (selector ending in "error:") may be
+                    // called with the trailing error argument omitted.
+                    if (const NativeApiMember* withError = selectMethodMember(
+                            classMembers, memberName, false, count + 1)) {
+                      const std::string& sel = withError->selectorName;
+                      if (sel.size() >= 6 &&
+                          sel.compare(sel.size() - 6, 6, "error:") == 0) {
+                        selected = withError;
+                      }
                     }
                   }
+                  if (selected == nullptr) {
+                    throw JSError(
+                        runtime,
+                        "Objective-C selector is not available for the provided "
+                        "arguments count: " +
+                            memberName);
+                  }
+                  auto prepared = prepareNativeApiObjCInvocation(
+                      runtime, bridge, object_getClass(self->object_), false,
+                      selected->selectorName, selected);
+                  cached = preparedCache
+                               ->emplace(count, std::make_pair(
+                                                    selected->selectorName,
+                                                    std::move(prepared)))
+                               .first;
                 }
-                if (selected == nullptr) {
-                  throw JSError(
-                      runtime,
-                      "Objective-C selector is not available for the provided "
-                      "arguments count: " +
-                          memberName);
-                }
-                if (auto self = weakSelf.lock()) {
-                  return self->callObjectSelector(
-                      runtime, selected->selectorName, selected, args, count);
-                }
-                return callObjCSelector(runtime, bridge, object, false,
-                                        selected->selectorName, selected, args,
-                                        count);
+                return self->callPreparedObjectSelector(
+                    runtime, cached->second.first, *cached->second.second, args,
+                    count);
               });
           // Cache the resolved host function so repeated method access does not
           // reallocate it on every call (hot path).