fix(ios): NSError** runtime fallback and enriched arg-count diagnostics

NativeScript/runtime/ArgConverter.mm

@@ -104,9 +104,24 @@
   if ((!meta->hasErrorOutParameter() && args.Length() != argsCount) ||
       (meta->hasErrorOutParameter() && args.Length() != argsCount &&
        args.Length() != argsCount - 1)) {
+    // NOTE: The message used to read "Actual arguments count: <expected>. Expected: <actual>.",
+    // which had the two numbers swapped. This made the log impossible to act on without reading
+    // the runtime source. We now spell it out (with swap corrected) and include the call site.
+    const char* jsNameStr = meta ? meta->jsName() : "<unknown>";
+    const char* selectorStr = meta ? meta->selectorAsString() : "<unknown>";
+    const char* classNameStr = klass ? class_getName(klass) : "<unknown>";
+    const char* methodKindStr = instanceMethod ? "instance" : "static";
+
     std::ostringstream errorStream;
-    errorStream << "Actual arguments count: \"" << argsCount << ". Expected: \"" << args.Length()
-                << "\".";
+    errorStream << "Actual arguments count: \"" << args.Length() << "\". Expected: \"" << argsCount
+                << "\"";
+    if (meta && meta->hasErrorOutParameter()) {
+      errorStream << " (or \"" << (argsCount - 1)
+                  << "\" if omitting the trailing NSError** out-parameter)";
+    }
+    errorStream << " for " << methodKindStr << " method \"" << jsNameStr << "\" on class \""
+                << classNameStr << "\" (selector: -[" << classNameStr << " " << selectorStr
+                << "]).";
     std::string errorMessage = errorStream.str();
     throw NativeScriptException(errorMessage);
   }

NativeScript/runtime/Metadata.h

@@ -1,6 +1,7 @@
 #ifndef Metadata_h
 #define Metadata_h
 
+#include <cstring>
 #include <stack>
 #include <string>
 #include <type_traits>
@@ -748,7 +749,37 @@ struct MethodMeta : MemberMeta {
     }
 
     inline bool hasErrorOutParameter() const {
-        return this->flag(MetaFlags::MethodHasErrorOutParameter);
+        if (this->flag(MetaFlags::MethodHasErrorOutParameter)) {
+            return true;
+        }
+
+        // Fallback: The MethodHasErrorOutParameter flag is set by the metadata
+        // generator via a type-tree walk that historically missed methods whose
+        // last parameter uses `_Nullable` nullability (e.g.
+        // `NSError * _Nullable * _Nullable` on modern iOS SDK headers).
+        // The *binary* encoding does preserve the underlying shape (NullableType
+        // is unwrapped during serialization), so we can recover the missing
+        // signal by inspecting the last parameter encoding directly. This keeps
+        // apps built against older/buggy metadata working with the auto-error
+        // handling in Interop::CallFunctionInternal and ArgConverter::Invoke.
+        const TypeEncodingsList<ArrayCount>* enc = this->encodings();
+        if (enc == nullptr || enc->count < 2) {
+            return false;
+        }
+        // TypeEncodingsList layout: [returnType, param1, param2, ..., lastParam]
+        const TypeEncoding* cur = enc->first();
+        for (int i = 0; i < enc->count - 1; i++) {
+            cur = cur->next();
+        }
+        if (cur == nullptr || cur->type != BinaryTypeEncodingType::PointerEncoding) {
+            return false;
+        }
+        const TypeEncoding* innerEnc = cur->details.pointer.getInnerType();
+        if (innerEnc == nullptr || innerEnc->type != BinaryTypeEncodingType::InterfaceDeclarationReference) {
+            return false;
+        }
+        const char* innerName = innerEnc->details.interfaceDeclarationReference.name.valuePtr();
+        return innerName != nullptr && strcmp(innerName, "NSError") == 0;
     }
 
     inline bool isInitializer() const {

NativeScript/runtime/ObjectManager.mm

@@ -176,7 +176,8 @@
 
     if (info.Length() != 1) {
         std::ostringstream errorStream;
-        errorStream << "Actual arguments count: \"" << info.Length() << "\". Expected: \"1\".";
+        errorStream << "Actual arguments count: \"" << info.Length() << "\". Expected: \"1\"."
+                    << " (function: __releaseNativeCounterpart(nativeObject))";
         std::string errorMessage = errorStream.str();
         Local<Value> error = Exception::Error(tns::ToV8String(isolate, errorMessage));
         isolate->ThrowException(error);

metadata-generator/src/Meta/MetaFactory.cpp

@@ -490,6 +490,17 @@ void MetaFactory::createFromMethod(const clang::ObjCMethodDecl& method,
                       isNullTerminatedVariadic);
 
   // set MethodHasErrorOutParameter flag
+  //
+  // Modern iOS SDK headers annotate out-error parameters as
+  // `NSError * _Nullable * _Nullable`, which TypeFactory wraps in
+  // `NullableType`/`NonNullableType` nodes (see
+  // `TypeFactory::createFromAttributedType`). The original implementation only
+  // checked for a raw `PointerType(InterfaceType("NSError"))` and therefore
+  // missed the vast majority of NSError**-returning Objective-C selectors
+  // (createDirectoryAtPath:...:error:, removeItemAtPath:error:, etc.). Unwrap
+  // the nullability wrapper at both the outer pointer and inner interface
+  // levels so the flag is set correctly whether or not the SDK annotates
+  // nullability.
   if (method.parameters().size() > 0) {
     clang::ParmVarDecl* lastParameter =
         method.parameters()[method.parameters().size() - 1];