fix: enumerate JS indexed collection subclasses

Author: DjDeveloperr

NativeScript/ffi/shared/bridge/Install.mm

@@ -242,14 +242,26 @@ function nativeExtensionMethodsWithIndexedCollectionAliases(methods) {
       return methods;
     }
 
+    var hasObjectAtIndex =
+      Object.prototype.hasOwnProperty.call(methods, 'objectAtIndex');
+    var hasCount =
+      Object.prototype.hasOwnProperty.call(methods, 'count');
+    var hasSymbolIterator =
+      typeof Symbol === 'function' && Symbol.iterator &&
+      Object.prototype.hasOwnProperty.call(methods, Symbol.iterator);
     var needsObjectAtIndexedSubscript =
-      Object.prototype.hasOwnProperty.call(methods, 'objectAtIndex') &&
+      hasObjectAtIndex &&
       !Object.prototype.hasOwnProperty.call(methods, 'objectAtIndexedSubscript');
     var needsSetObjectAtIndexedSubscript =
       Object.prototype.hasOwnProperty.call(methods, 'replaceObjectAtIndexWithObject') &&
       !Object.prototype.hasOwnProperty.call(methods, 'setObjectAtIndexedSubscript');
+    var needsIndexedCollectionIterator =
+      typeof Symbol === 'function' && Symbol.iterator &&
+      hasObjectAtIndex && hasCount && !hasSymbolIterator;
 
-    if (!needsObjectAtIndexedSubscript && !needsSetObjectAtIndexedSubscript) {
+    if (!needsObjectAtIndexedSubscript &&
+        !needsSetObjectAtIndexedSubscript &&
+        !needsIndexedCollectionIterator) {
       return methods;
     }
 
@@ -278,9 +290,57 @@ function nativeExtensionMethodsWithIndexedCollectionAliases(methods) {
       });
     }
 
+    if (needsIndexedCollectionIterator) {
+      Object.defineProperty(prepared, Symbol.iterator, {
+        configurable: true,
+        enumerable: false,
+        writable: true,
+        value: function() {
+          var receiver = this;
+          var index = 0;
+          return {
+            next: function() {
+              var countValue = receiver.count;
+              var count = typeof countValue === 'function'
+                ? countValue.call(receiver)
+                : countValue;
+              if (!(index < count)) {
+                return { done: true };
+              }
+              return {
+                value: receiver.objectAtIndex(index++),
+                done: false
+              };
+            }
+          };
+        }
+      });
+    }
+
     return prepared;
   }
 
+  function nativeExtensionMethodsHaveIterator(methods) {
+    return typeof Symbol === 'function' && Symbol.iterator &&
+      methods != null && typeof methods === 'object' &&
+      Object.prototype.hasOwnProperty.call(methods, Symbol.iterator);
+  }
+
+  function nativeExtensionOptionsWithIterator(options, methods) {
+    var extendOptions = options || {};
+    if (!nativeExtensionMethodsHaveIterator(methods)) {
+      return extendOptions;
+    }
+    try {
+      return Object.assign({}, extendOptions, {
+        __hasIterator: true
+      });
+    } catch (_) {
+      extendOptions.__hasIterator = true;
+      return extendOptions;
+    }
+  }
+
   Object.defineProperty(globalThis, '__nativeScriptCreateNativeApiIterator', {
     configurable: false,
     enumerable: false,
@@ -753,17 +813,8 @@ function rememberInstanceClass(instance) {
             throw new Error('extend() first parameter must be an object');
           }
           var extensionMethods = nativeExtensionMethodsWithIndexedCollectionAliases(methods);
-          var extendOptions = options || {};
-          if (typeof Symbol === 'function' &&
-              Object.prototype.hasOwnProperty.call(methods, Symbol.iterator)) {
-            try {
-              extendOptions = Object.assign({}, extendOptions, {
-                __hasIterator: true
-              });
-            } catch (_) {
-              extendOptions.__hasIterator = true;
-            }
-          }
+          var extendOptions =
+            nativeExtensionOptionsWithIterator(options, extensionMethods);
           var extendedNativeClass = api.__extendClass(nativeClass, extensionMethods, extendOptions);
           var extended = wrapNativeClass(extendedNativeClass);
           try {
@@ -1405,10 +1456,11 @@ function materializeTypeScriptNativeClass(constructor) {
 	        options.exposedMethods = constructor.ObjCExposedMethods;
 	      }
 
-	      var nativeBase = nativeClassLikeHandle(baseWrapper);
-	      var extensionMethods =
-	        nativeExtensionMethodsWithIndexedCollectionAliases(constructor.prototype || {});
-	      var nativeClass = api.__extendClass(nativeBase, extensionMethods, options);
+		      var nativeBase = nativeClassLikeHandle(baseWrapper);
+		      var extensionMethods =
+		        nativeExtensionMethodsWithIndexedCollectionAliases(constructor.prototype || {});
+		      options = nativeExtensionOptionsWithIterator(options, extensionMethods);
+		      var nativeClass = api.__extendClass(nativeBase, extensionMethods, options);
 	      var wrapper = wrapNativeClass(nativeClass);
 	      state.wrapper = wrapper;
 

PROGRESS.md

@@ -17,6 +17,48 @@ TypeScript/UI worklets.
 
 ## Latest Update - 2026-06-29
 
+### 2026-06-29 22:20 EDT - indexed collection fast enumeration for JS subclasses
+
+- CI finding:
+  - GitHub Actions run `28414381388` on `7d7e9d3f` kept setup,
+    dependency install, FFI boundary check, V8 download, libffi build,
+    metadata generation, NativeScript build, CLI build, and macOS tests green.
+  - The previous macOS `MethodCallsTests` and `ApiTests.js
+    NSMutableArrayMethods` failures were fixed.
+  - iOS simulator still timed out in `ApiTests.js NSMutableArrayMethods`.
+    Verbose-spec logs showed `MethodCallsTests`, `ApiTests.js Appearance`,
+    and the immediately preceding `ApiTests` specs passed, then the run hung
+    after `SPEC START ... ApiTests.js NSMutableArrayMethods` with no completed
+    JUnit file.
+- Root cause refinement:
+  - The remaining iOS-only hang is consistent with native fast enumeration of
+    a JS-backed `NSMutableArray` subclass relying on Foundation's inherited
+    `NSArray` enumeration behavior instead of a bridge-owned JS primitive path.
+  - The subclass implements the indexed collection contract (`count` and
+    `objectAtIndex`) but does not explicitly provide `Symbol.iterator`, so the
+    existing NativeScript fast-enumeration bridge was not installed.
+- Changes:
+  - JS native-class extension preparation now synthesizes a non-enumerable
+    `Symbol.iterator` for indexed collection subclasses that provide
+    `count` and `objectAtIndex`.
+  - Both `.extend(...)` and TypeScript `NativeClass` materialization now enable
+    the existing native fast-enumeration bridge from the prepared method set,
+    including synthesized iterators.
+  - The existing indexed subscript aliases remain in place.
+- Verification:
+  - `node packages/react-native/test/runtime-indexed-collection-alias.test.js`
+    passed.
+  - Runtime RN JS tests passed:
+    `for f in packages/react-native/test/*.test.js; do node "$f" || exit 1; done`.
+  - `git diff --check` passed.
+  - `npm run check:ffi-boundaries` passed.
+  - `npm run build:macos-cli` passed.
+- Still next:
+  - Commit/push this indexed collection fast-enumeration fix and watch fresh PR
+    CI for the iOS simulator `NSMutableArrayMethods` result.
+  - If CI turns green, resume the dedicated simulator-only RNS parity sweep
+    against original RNS.
+
 ### 2026-06-29 21:15 EDT - initializer self-return receiver preservation
 
 - Goal:

RN_API.md

@@ -68,6 +68,21 @@ UIKit-backed React Native libraries in TypeScript/UI worklets.
   - Prototype setters remain authoritative and must not be shadowed by the
     expando fallback.
 
+## 2026-06-29 JS Indexed Collection Fast Enumeration
+
+- No new public NativeScript React Native API was added.
+- Generic native bridge behavior was clarified for JS/TypeScript native
+  subclasses:
+  - JS-backed indexed collection subclasses that provide `count` and
+    `objectAtIndex` should expose a bridge-owned iterator when they do not
+    define `Symbol.iterator` themselves.
+  - The existing native fast-enumeration bridge should be installed from the
+    prepared method set for both `.extend(...)` and TypeScript `NativeClass`
+    materialization, including synthesized indexed-collection iterators.
+  - Native `for...in`/`NSFastEnumeration` over JS-backed NSArray/NSMutableArray
+    subclasses should enumerate through the JS indexed primitive contract
+    rather than relying on platform-specific inherited Foundation behavior.
+
 ## 2026-06-29 Simulator Latency Comparison
 
 - No new public NativeScript React Native API was added.

packages/react-native/test/runtime-indexed-collection-alias.test.js

@@ -24,15 +24,29 @@ for (const relativePath of [
       source.includes("return this.replaceObjectAtIndexWithObject(index, anObject);"),
     `${relativePath}: synthesized subscript aliases should delegate to the JS primitive methods with native argument order corrected`,
   );
+  assert(
+    source.includes("needsIndexedCollectionIterator") &&
+      source.includes("Object.defineProperty(prepared, Symbol.iterator") &&
+      source.includes("value: receiver.objectAtIndex(index++)"),
+    `${relativePath}: JS-backed indexed collection subclasses should synthesize Symbol.iterator from count/objectAtIndex`,
+  );
+  assert(
+    source.includes("function nativeExtensionOptionsWithIterator(options, methods)") &&
+      source.includes("nativeExtensionMethodsHaveIterator(methods)") &&
+      source.includes("__hasIterator: true"),
+    `${relativePath}: prepared indexed collection iterators should enable the native fast-enumeration bridge`,
+  );
   assert(
     source.includes("var extensionMethods = nativeExtensionMethodsWithIndexedCollectionAliases(methods);") &&
+      source.includes("nativeExtensionOptionsWithIterator(options, extensionMethods)") &&
       source.includes("api.__extendClass(nativeClass, extensionMethods, extendOptions)") &&
       source.includes("Object.getOwnPropertyDescriptors(extensionMethods)") &&
       source.includes("Object.keys(extensionMethods)"),
     `${relativePath}: NativeClass.extend should register and expose the prepared indexed collection method set`,
   );
   assert(
     source.includes("nativeExtensionMethodsWithIndexedCollectionAliases(constructor.prototype || {})") &&
+      source.includes("options = nativeExtensionOptionsWithIterator(options, extensionMethods)") &&
       source.includes("api.__extendClass(nativeBase, extensionMethods, options)") &&
       source.includes("api.__rememberClassWrapper(nativeClass, constructor, extensionMethods)"),
     `${relativePath}: TypeScript native class materialization should use the same prepared method set`,