Fixes mutations within fixed sizes arrays

Author: mustiikhalil

src/idl_gen_swift.cpp

@@ -428,9 +428,21 @@ class SwiftGenerator : public BaseGenerator {
                  GenConstructor("{{ACCESS}}.position + {{OFFSET}}");
       }
 
-      if (parser_.opts.mutable_buffer && !IsStruct(field.value.type) &&
-          !IsArray(field.value.type))
-        code_ += GenMutate("{{OFFSET}}", "", IsEnum(field.value.type));
+      if (parser_.opts.mutable_buffer) {
+        if (!IsStruct(field.value.type) && !IsArray(field.value.type)) {
+          code_ += GenMutate("{{OFFSET}}", "", IsEnum(field.value.type));
+        } else if (IsArray(field.value.type) &&
+                   !IsStruct(field.value.type.VectorType())) {
+          code_.SetValue("IS_RAW", IsEnum(field.value.type.VectorType())
+                                       ? ".rawValue"
+                                       : "");
+          code_ +=
+              "@discardableResult {{ACCESS_TYPE}} func mutate({{FIELDVAR}}: "
+              "{{VALUETYPE}}, at index: Int32) -> Bool { "
+              "return {{ACCESS}}.mutate({{FIELDVAR}}{{IS_RAW}}, index: "
+              "{{OFFSET_VALUE}} + (index * {{SIZE}})) }";
+        }
+      }
     }
 
     if (parser_.opts.generate_object_based_api) {

tests/swift/Tests/Flatbuffers/FlatBuffersArraysTests.swift

@@ -5,13 +5,15 @@
 //  Created by Gwen on 2025-11-04.
 //
 
+#if compiler(>=6.2)
+
 import XCTest
 
 @testable import FlatBuffers
 
 @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, *)
 final class FlatBuffersArraysTests: XCTestCase {
-  
+
   func testGoldenData() throws {
     // swiftformat:disable all
     let data: [UInt8] = [
@@ -27,9 +29,9 @@ final class FlatBuffersArraysTests: XCTestCase {
       255, 255, 255, 255, 255, 255, 127
     ]
     // swiftformat:enable all
-    
+
     var builder = FlatBufferBuilder(initialSize: 1024)
-    
+
     let nestedStruct1 = MyGame_Example_NestedStruct(
       a: [-1, 2],
       b: .a,
@@ -52,22 +54,22 @@ final class FlatBuffersArraysTests: XCTestCase {
       e: 1,
       f: [-0x8000000000000000, 0x7FFFFFFFFFFFFFFF]
     )
-    
+
     let arrayTable = MyGame_Example_ArrayTable.createArrayTable(&builder, a: arrayStruct)
     builder.finish(offset: arrayTable, fileId: "ARRT")
-    
+
     let array = builder.sizedByteArray
-    
+
     XCTAssertEqual(data, array)
-    
+
     var buf = ByteBuffer(bytes: array)
     let table: MyGame_Example_ArrayTable = try getCheckedRoot(byteBuffer: &buf, fileId: "ARRT")
-    verify(a: table.a)
-    mutate(table: table)
-    verify(a: table.a)
+    testNativeStruct(a: table.a)
+    testMutations(in: table)
+    testNativeStruct(a: table.a)
   }
-  
-  func verify(a: MyGame_Example_ArrayStruct?) {
+
+  func testNativeStruct(a: MyGame_Example_ArrayStruct?) {
     let a = a!
     XCTAssertEqual(a.a, 12.34)
     XCTAssertEqual(a.b.count, 15)
@@ -93,8 +95,8 @@ final class FlatBuffersArraysTests: XCTestCase {
     XCTAssertEqual(a.e, 1)
     XCTAssertEqual(a.f.count, 2)
   }
-  
-  func mutate(table: MyGame_Example_ArrayTable) {
+
+  func testMutations(in table: MyGame_Example_ArrayTable) {
     let a = table.mutableA!
     XCTAssertEqual(a.a, 12.34)
     XCTAssertEqual(a.b.count, 15)
@@ -106,7 +108,7 @@ final class FlatBuffersArraysTests: XCTestCase {
     XCTAssertEqual(a.c, -127)
     XCTAssertEqual(a.d.count, 2)
     let nestedStruct1 = a.d[0]
-    
+
     XCTAssertEqual(nestedStruct1.a.reduce(0) { $0 + $1 }, 1)
     XCTAssertEqual(nestedStruct1.b, .a)
     XCTAssertEqual(nestedStruct1.c[0], .c)
@@ -119,6 +121,37 @@ final class FlatBuffersArraysTests: XCTestCase {
     XCTAssertEqual(nestedStruct2.c[1], .a)
     XCTAssertEqual(nestedStruct2.d[0], -0x1122334455667788)
     XCTAssertEqual(nestedStruct2.d[1], 0x1122334455667788)
+    
+    XCTAssertTrue(a.mutate(b: 1000, at: 0))
+    XCTAssertTrue(a.mutate(b: 2000, at: 1))
+    
+    XCTAssertTrue(nestedStruct2.mutate(c: .a, at: 0))
+    XCTAssertTrue(nestedStruct2.mutate(c: .b, at: 1))
+
+    XCTAssertEqual(nestedStruct2.c[0], .a)
+    XCTAssertEqual(nestedStruct2.c[1], .b)
+    
+    XCTAssertTrue(nestedStruct2.mutate(d: 0, at: 0))
+    XCTAssertTrue(nestedStruct2.mutate(d: 0, at: 1))
+
+    XCTAssertEqual(nestedStruct2.d.reduce(0) { $0 + $1 }, 0)
+    
+    let nativeStruct = table.a?.d[1]
+    
+    XCTAssertEqual(nativeStruct?.c[0], .a)
+    XCTAssertEqual(nativeStruct?.c[1], .b)
+    
+    XCTAssertEqual(nativeStruct?.d[0], 0)
+    XCTAssertEqual(nativeStruct?.d[1], 0)
+    
+    XCTAssertTrue(a.mutate(b: 1, at: 0))
+    XCTAssertTrue(a.mutate(b: 2, at: 1))
+    
+    XCTAssertTrue(nestedStruct2.mutate(c: .b, at: 0))
+    XCTAssertTrue(nestedStruct2.mutate(c: .a, at: 1))
+
+    XCTAssertTrue(nestedStruct2.mutate(d: -0x1122334455667788, at: 0))
+    XCTAssertTrue(nestedStruct2.mutate(d: 0x1122334455667788, at: 1))
   }
 }
 
@@ -132,3 +165,6 @@ extension InlineArray {
     return result
   }
 }
+
+#endif
+

tests/swift/Tests/Flatbuffers/arrays_test_generated.swift

@@ -121,10 +121,13 @@ public struct MyGame_Example_NestedStruct_Mutable: FlatBufferStruct, Flatbuffers
   public init(_ bb: ByteBuffer, o: Int32) { _accessor = Struct(bb: bb, position: o) }
 
   public var a: FlatbufferVector<Int32> { return _accessor.vector(at: 0, count: 2, size: 4) }
+  @discardableResult public func mutate(a: Int32, at index: Int32) -> Bool { return _accessor.mutate(a, index: 0 + (index * 4)) }
   public var b: MyGame_Example_TestEnum { return MyGame_Example_TestEnum(rawValue: _accessor.readBuffer(of: Int8.self, at: 8)) ?? .a }
   @discardableResult public func mutate(b: MyGame_Example_TestEnum) -> Bool { return _accessor.mutate(b.rawValue, index: 8) }
   public var c: FlatbufferVector<MyGame_Example_TestEnum> { return _accessor.vector(at: 9, count: 2, size: 1) }
+  @discardableResult public func mutate(c: MyGame_Example_TestEnum, at index: Int32) -> Bool { return _accessor.mutate(c.rawValue, index: 9 + (index * 1)) }
   public var d: FlatbufferVector<Int64> { return _accessor.vector(at: 16, count: 2, size: 8) }
+  @discardableResult public func mutate(d: Int64, at index: Int32) -> Bool { return _accessor.mutate(d, index: 16 + (index * 8)) }
 
   public func unpack() -> MyGame_Example_NestedStruct {
     return MyGame_Example_NestedStruct(self)
@@ -250,12 +253,14 @@ public struct MyGame_Example_ArrayStruct_Mutable: FlatBufferStruct, FlatbuffersV
   public var a: Float32 { return _accessor.readBuffer(of: Float32.self, at: 0) }
   @discardableResult public func mutate(a: Float32) -> Bool { return _accessor.mutate(a, index: 0) }
   public var b: FlatbufferVector<Int32> { return _accessor.vector(at: 4, count: 15, size: 4) }
+  @discardableResult public func mutate(b: Int32, at index: Int32) -> Bool { return _accessor.mutate(b, index: 4 + (index * 4)) }
   public var c: Int8 { return _accessor.readBuffer(of: Int8.self, at: 64) }
   @discardableResult public func mutate(c: Int8) -> Bool { return _accessor.mutate(c, index: 64) }
   public var d: FlatbufferVector<MyGame_Example_NestedStruct_Mutable> { return _accessor.vector(at: 72, count: 2, size: 32) }
   public var e: Int32 { return _accessor.readBuffer(of: Int32.self, at: 136) }
   @discardableResult public func mutate(e: Int32) -> Bool { return _accessor.mutate(e, index: 136) }
   public var f: FlatbufferVector<Int64> { return _accessor.vector(at: 144, count: 2, size: 8) }
+  @discardableResult public func mutate(f: Int64, at index: Int32) -> Bool { return _accessor.mutate(f, index: 144 + (index * 8)) }
 
   public func unpack() -> MyGame_Example_ArrayStruct {
     return MyGame_Example_ArrayStruct(self)