Made indexed assignment throw on read-only indexable collections

Indexed assignment (obj[i] = x) silently no-op'd for any non-NSMutableArray target, letting V8 store an unreachable JS property on the wrapper. Now that non-NSArray collections are readable by index, throw a TypeError for indexable read-only targets (responds to count + objectAtIndex:, not NSMutableArray) so a dropped write surfaces instead of leaking an orphaned expando. NSArray keeps its silent no-op for backward compatibility.

Author: adrian-niculescu

NativeScript/runtime/ArgConverter.mm

@@ -961,6 +961,16 @@
   ObjCDataWrapper* objcDataWrapper = static_cast<ObjCDataWrapper*>(wrapper);
   id target = objcDataWrapper->Data();
   if (![target isKindOfClass:[NSMutableArray class]]) {
+    // Indexed assignment is only supported for NSMutableArray. Other indexable
+    // collections (e.g. NSOrderedSet, PHFetchResult) reject the write so it can't be
+    // silently dropped into an unreachable JS property on the wrapper. NSArray is
+    // excluded from the throw and falls through to a silent no-op.
+    if ([target respondsToSelector:@selector(count)] &&
+        [target respondsToSelector:@selector(objectAtIndex:)] &&
+        ![target isKindOfClass:[NSArray class]]) {
+      isolate->ThrowException(Exception::TypeError(
+          tns::ToV8String(isolate, "Indexed assignment is only supported for NSMutableArray")));
+    }
     return;
   }
 

TestRunner/app/tests/ApiTests.js

@@ -36,6 +36,31 @@ describe(module.id, function () {
         expect(set[3]).toBeUndefined();
     });
 
+    it("indexed assignment throws for read-only indexable collections", function () {
+        const set = NSOrderedSet.orderedSetWithArray(['a', 'b', 'c']);
+        // NSOrderedSet is indexable but not writable, so indexed assignment throws.
+        // The index is irrelevant; the whole collection rejects writes.
+        expect(function () { set[0] = 'ghost'; }).toThrowError(TypeError, /Indexed assignment is only supported for NSMutableArray/);
+        expect(function () { set[5] = 'ghost'; }).toThrowError(TypeError);
+        // The rejected out-of-range write left no stray JS property behind, the native
+        // collection is untouched, and reads still resolve native elements.
+        expect(Object.prototype.hasOwnProperty.call(set, '5')).toBe(false);
+        expect(set.count).toBe(3);
+        expect(set[0]).toBe('a');
+        expect(set[5]).toBeUndefined();
+    });
+
+    it("indexed assignment still works for NSMutableArray", function () {
+        const first = NSObject.new();
+        const arr = NSMutableArray.arrayWithArray([first, NSObject.new()]);
+        const replacement = NSObject.new();
+
+        arr[0] = replacement;
+        expect(arr.count).toBe(2);
+        expect(arr.objectAtIndex(0)).toBe(replacement);
+        expect(arr[0]).toBe(replacement);
+    });
+
     it("MethodCalledInDealloc", function () {
         expect(function () {
             (function () {