Fixes grammer (#6477)

Updates docs

docs/source/Tutorial.md

@@ -1715,15 +1715,15 @@ can serialize the monster itself:
 <div class="language-swift">
 ~~~{.swift}
   let orc = Monster.createMonster(
-    fbb: &builder,
+    &builder,
-    pos: Vec3(x: 1, y: 2, z: 3),
+    pos: MyGame_Sample_Vec3(x: 1, y: 2, z: 3),
     hp: 300,
-    name: name,
+    nameOffset: name,
-    inventory: inventoryOffset,
+    inventoryVectorOffset: inventoryOffset,
     color: .red,
-    weapons: weaponsOffset,
+    weaponsVectorOffset: weaponsOffset,
     equippedType: .weapon,
-    equipped: axe)
+    equippedOffset: axe)
 ~~~
 </div>
 

samples/monster_generated.swift

@@ -137,13 +137,13 @@ public struct MyGame_Sample_Monster: FlatBufferObject {
     pos: MyGame_Sample_Vec3? = nil,
     mana: Int16 = 150,
     hp: Int16 = 100,
-    offsetOfName name: Offset<String> = Offset(),
+    nameOffset name: Offset<String> = Offset(),
-    vectorOfInventory inventory: Offset<UOffset> = Offset(),
+    inventoryVectorOffset inventory: Offset<UOffset> = Offset(),
     color: MyGame_Sample_Color = .blue,
-    vectorOfWeapons weapons: Offset<UOffset> = Offset(),
+    weaponsVectorOffset weapons: Offset<UOffset> = Offset(),
     equippedType: MyGame_Sample_Equipment = .none_,
-    offsetOfEquipped equipped: Offset<UOffset> = Offset(),
+    equippedOffset equipped: Offset<UOffset> = Offset(),
-    vectorOfPath path: Offset<UOffset> = Offset()
+    pathVectorOffset path: Offset<UOffset> = Offset()
   ) -> Offset<UOffset> {
     let __start = MyGame_Sample_Monster.startMonster(&fbb)
     MyGame_Sample_Monster.add(pos: pos, &fbb)
@@ -188,7 +188,7 @@ public struct MyGame_Sample_Weapon: FlatBufferObject {
   public static func endWeapon(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
   public static func createWeapon(
     _ fbb: inout FlatBufferBuilder,
-    offsetOfName name: Offset<String> = Offset(),
+    nameOffset name: Offset<String> = Offset(),
     damage: Int16 = 0
   ) -> Offset<UOffset> {
     let __start = MyGame_Sample_Weapon.startWeapon(&fbb)

samples/sample_binary.swift

@@ -46,14 +46,14 @@ func main() {
 
   let orc = Monster.createMonster(
     &builder,
-    structOfPos: MyGame_Sample_Vec3(x: 1, y: 2, z: 3),
+    pos: MyGame_Sample_Vec3(x: 1, y: 2, z: 3),
     hp: 300,
-    offsetOfName: name,
+    nameOffset: name,
-    vectorOfInventory: inventoryOffset,
+    inventoryVectorOffset: inventoryOffset,
     color: .red,
-    vectorOfWeapons: weaponsOffset,
+    weaponsVectorOffset: weaponsOffset,
     equippedType: .weapon,
-    offsetOfEquipped: axe)
+    equippedOffset: axe)
   builder.finish(offset: orc)
 
   let buf = builder.sizedByteArray

src/idl_gen_swift.cpp

@@ -605,9 +605,10 @@ class SwiftGenerator : public BaseGenerator {
     auto offset_type =
         IsString(field.value.type) ? "Offset<String>" : "Offset<UOffset>";
     auto camel_case_name =
-        (IsVector(field.value.type) || IsArray(field.value.type) ? "vectorOf"
+        MakeCamel(name, false) +
-                                                                 : "offsetOf") +
+        (IsVector(field.value.type) || IsArray(field.value.type)
-        MakeCamel(name, true);
+             ? "VectorOffset"
+             : "Offset");
     create_func_header.push_back(camel_case_name + " " + name + ": " +
                                  offset_type + " = Offset()");
     auto reader_type =

tests/FlatBuffers.GRPC.Swift/Sources/Model/greeter_generated.swift

@@ -28,7 +28,7 @@ public struct HelloReply: FlatBufferObject {
   public static func endHelloReply(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
   public static func createHelloReply(
     _ fbb: inout FlatBufferBuilder,
-    offsetOfMessage message: Offset<String> = Offset()
+    messageOffset message: Offset<String> = Offset()
   ) -> Offset<UOffset> {
     let __start = HelloReply.startHelloReply(&fbb)
     HelloReply.add(message: message, &fbb)
@@ -60,7 +60,7 @@ public struct HelloRequest: FlatBufferObject {
   public static func endHelloRequest(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
   public static func createHelloRequest(
     _ fbb: inout FlatBufferBuilder,
-    offsetOfName name: Offset<String> = Offset()
+    nameOffset name: Offset<String> = Offset()
   ) -> Offset<UOffset> {
     let __start = HelloRequest.startHelloRequest(&fbb)
     HelloRequest.add(name: name, &fbb)
@@ -95,7 +95,7 @@ public struct ManyHellosRequest: FlatBufferObject {
   public static func endManyHellosRequest(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
   public static func createManyHellosRequest(
     _ fbb: inout FlatBufferBuilder,
-    offsetOfName name: Offset<String> = Offset(),
+    nameOffset name: Offset<String> = Offset(),
     numGreetings: Int32 = 0
   ) -> Offset<UOffset> {
     let __start = ManyHellosRequest.startManyHellosRequest(&fbb)

tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersMonsterWriterTests.swift

@@ -104,7 +104,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
     var fbb = FlatBufferBuilder(initialSize: 1)
     let name = fbb.create(string: "Frodo")
     let bools = fbb.createVector(boolArray)
-    let root = Monster.createMonster(&fbb, offsetOfName: name, vectorOfTestarrayofbools: bools)
+    let root = Monster.createMonster(&fbb, nameOffset: name, testarrayofboolsVectorOffset: bools)
     fbb.finish(offset: root)
     let monster = Monster.getRootAsMonster(bb: fbb.sizedBuffer)
 

tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersUnionTests.swift

@@ -107,7 +107,10 @@ final class FlatBuffersUnionTests: XCTestCase {
     ]
     let types = fb.createVector(characterType)
     let characterVector = fb.createVector(ofOffsets: characters)
-    let end = Movie.createMovie(&fb, vectorOfCharactersType: types, vectorOfCharacters: characterVector)
+    let end = Movie.createMovie(
+      &fb,
+      charactersTypeVectorOffset: types,
+      charactersVectorOffset: characterVector)
     Movie.finish(&fb, end: end)
 
     var movie = Movie.getRootAsMovie(bb: fb.buffer)

tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift

@@ -514,7 +514,7 @@ public struct MyGame_Example_Stat: FlatBufferObject, ObjectAPIPacker {
   public static func endStat(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
   public static func createStat(
     _ fbb: inout FlatBufferBuilder,
-    offsetOfId id: Offset<String> = Offset(),
+    idOffset id: Offset<String> = Offset(),
     val: Int64 = 0,
     count: UInt16 = 0
   ) -> Offset<UOffset> {
@@ -936,17 +936,17 @@ public struct MyGame_Example_Monster: FlatBufferObject, ObjectAPIPacker {
     pos: MyGame_Example_Vec3? = nil,
     mana: Int16 = 150,
     hp: Int16 = 100,
-    offsetOfName name: Offset<String> = Offset(),
+    nameOffset name: Offset<String> = Offset(),
-    vectorOfInventory inventory: Offset<UOffset> = Offset(),
+    inventoryVectorOffset inventory: Offset<UOffset> = Offset(),
     color: MyGame_Example_Color = .blue,
     testType: MyGame_Example_Any_ = .none_,
-    offsetOfTest test: Offset<UOffset> = Offset(),
+    testOffset test: Offset<UOffset> = Offset(),
-    vectorOfTest4 test4: Offset<UOffset> = Offset(),
+    test4VectorOffset test4: Offset<UOffset> = Offset(),
-    vectorOfTestarrayofstring testarrayofstring: Offset<UOffset> = Offset(),
+    testarrayofstringVectorOffset testarrayofstring: Offset<UOffset> = Offset(),
-    vectorOfTestarrayoftables testarrayoftables: Offset<UOffset> = Offset(),
+    testarrayoftablesVectorOffset testarrayoftables: Offset<UOffset> = Offset(),
-    offsetOfEnemy enemy: Offset<UOffset> = Offset(),
+    enemyOffset enemy: Offset<UOffset> = Offset(),
-    vectorOfTestnestedflatbuffer testnestedflatbuffer: Offset<UOffset> = Offset(),
+    testnestedflatbufferVectorOffset testnestedflatbuffer: Offset<UOffset> = Offset(),
-    offsetOfTestempty testempty: Offset<UOffset> = Offset(),
+    testemptyOffset testempty: Offset<UOffset> = Offset(),
     testbool: Bool = false,
     testhashs32Fnv1: Int32 = 0,
     testhashu32Fnv1: UInt32 = 0,
@@ -956,33 +956,33 @@ public struct MyGame_Example_Monster: FlatBufferObject, ObjectAPIPacker {
     testhashu32Fnv1a: UInt32 = 0,
     testhashs64Fnv1a: Int64 = 0,
     testhashu64Fnv1a: UInt64 = 0,
-    vectorOfTestarrayofbools testarrayofbools: Offset<UOffset> = Offset(),
+    testarrayofboolsVectorOffset testarrayofbools: Offset<UOffset> = Offset(),
     testf: Float32 = 3.14159,
     testf2: Float32 = 3.0,
     testf3: Float32 = 0.0,
-    vectorOfTestarrayofstring2 testarrayofstring2: Offset<UOffset> = Offset(),
+    testarrayofstring2VectorOffset testarrayofstring2: Offset<UOffset> = Offset(),
-    vectorOfTestarrayofsortedstruct testarrayofsortedstruct: Offset<UOffset> = Offset(),
+    testarrayofsortedstructVectorOffset testarrayofsortedstruct: Offset<UOffset> = Offset(),
-    vectorOfFlex flex: Offset<UOffset> = Offset(),
+    flexVectorOffset flex: Offset<UOffset> = Offset(),
-    vectorOfTest5 test5: Offset<UOffset> = Offset(),
+    test5VectorOffset test5: Offset<UOffset> = Offset(),
-    vectorOfVectorOfLongs vectorOfLongs: Offset<UOffset> = Offset(),
+    vectorOfLongsVectorOffset vectorOfLongs: Offset<UOffset> = Offset(),
-    vectorOfVectorOfDoubles vectorOfDoubles: Offset<UOffset> = Offset(),
+    vectorOfDoublesVectorOffset vectorOfDoubles: Offset<UOffset> = Offset(),
-    offsetOfParentNamespaceTest parentNamespaceTest: Offset<UOffset> = Offset(),
+    parentNamespaceTestOffset parentNamespaceTest: Offset<UOffset> = Offset(),
-    vectorOfVectorOfReferrables vectorOfReferrables: Offset<UOffset> = Offset(),
+    vectorOfReferrablesVectorOffset vectorOfReferrables: Offset<UOffset> = Offset(),
     singleWeakReference: UInt64 = 0,
-    vectorOfVectorOfWeakReferences vectorOfWeakReferences: Offset<UOffset> = Offset(),
+    vectorOfWeakReferencesVectorOffset vectorOfWeakReferences: Offset<UOffset> = Offset(),
-    vectorOfVectorOfStrongReferrables vectorOfStrongReferrables: Offset<UOffset> = Offset(),
+    vectorOfStrongReferrablesVectorOffset vectorOfStrongReferrables: Offset<UOffset> = Offset(),
     coOwningReference: UInt64 = 0,
-    vectorOfVectorOfCoOwningReferences vectorOfCoOwningReferences: Offset<UOffset> = Offset(),
+    vectorOfCoOwningReferencesVectorOffset vectorOfCoOwningReferences: Offset<UOffset> = Offset(),
     nonOwningReference: UInt64 = 0,
-    vectorOfVectorOfNonOwningReferences vectorOfNonOwningReferences: Offset<UOffset> = Offset(),
+    vectorOfNonOwningReferencesVectorOffset vectorOfNonOwningReferences: Offset<UOffset> = Offset(),
     anyUniqueType: MyGame_Example_AnyUniqueAliases = .none_,
-    offsetOfAnyUnique anyUnique: Offset<UOffset> = Offset(),
+    anyUniqueOffset anyUnique: Offset<UOffset> = Offset(),
     anyAmbiguousType: MyGame_Example_AnyAmbiguousAliases = .none_,
-    offsetOfAnyAmbiguous anyAmbiguous: Offset<UOffset> = Offset(),
+    anyAmbiguousOffset anyAmbiguous: Offset<UOffset> = Offset(),
-    vectorOfVectorOfEnums vectorOfEnums: Offset<UOffset> = Offset(),
+    vectorOfEnumsVectorOffset vectorOfEnums: Offset<UOffset> = Offset(),
     signedEnum: MyGame_Example_Race = .none_,
-    vectorOfTestrequirednestedflatbuffer testrequirednestedflatbuffer: Offset<UOffset> = Offset(),
+    testrequirednestedflatbufferVectorOffset testrequirednestedflatbuffer: Offset<UOffset> = Offset(),
-    vectorOfScalarKeySortedTables scalarKeySortedTables: Offset<UOffset> = Offset()
+    scalarKeySortedTablesVectorOffset scalarKeySortedTables: Offset<UOffset> = Offset()
   ) -> Offset<UOffset> {
     let __start = MyGame_Example_Monster.startMonster(&fbb)
     MyGame_Example_Monster.add(pos: pos, &fbb)
@@ -1528,8 +1528,8 @@ public struct MyGame_Example_TypeAliases: FlatBufferObject, ObjectAPIPacker {
     u64: UInt64 = 0,
     f32: Float32 = 0.0,
     f64: Double = 0.0,
-    vectorOfV8 v8: Offset<UOffset> = Offset(),
+    v8VectorOffset v8: Offset<UOffset> = Offset(),
-    vectorOfVf64 vf64: Offset<UOffset> = Offset()
+    vf64VectorOffset vf64: Offset<UOffset> = Offset()
   ) -> Offset<UOffset> {
     let __start = MyGame_Example_TypeAliases.startTypeAliases(&fbb)
     MyGame_Example_TypeAliases.add(i8: i8, &fbb)

tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/more_defaults_generated.swift

@@ -42,10 +42,10 @@ public struct MoreDefaults: FlatBufferObject, ObjectAPIPacker {
   public static func endMoreDefaults(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
   public static func createMoreDefaults(
     _ fbb: inout FlatBufferBuilder,
-    vectorOfInts ints: Offset<UOffset> = Offset(),
+    intsVectorOffset ints: Offset<UOffset> = Offset(),
-    vectorOfFloats floats: Offset<UOffset> = Offset(),
+    floatsVectorOffset floats: Offset<UOffset> = Offset(),
-    offsetOfEmptyString emptyString: Offset<String> = Offset(),
+    emptyStringOffset emptyString: Offset<String> = Offset(),
-    offsetOfSomeString someString: Offset<String> = Offset()
+    someStringOffset someString: Offset<String> = Offset()
   ) -> Offset<UOffset> {
     let __start = MoreDefaults.startMoreDefaults(&fbb)
     MoreDefaults.addVectorOf(ints: ints, &fbb)

tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/union_vector_generated.swift

@@ -237,9 +237,9 @@ public struct Movie: FlatBufferObject, ObjectAPIPacker {
   public static func createMovie(
     _ fbb: inout FlatBufferBuilder,
     mainCharacterType: Character = .none_,
-    offsetOfMainCharacter mainCharacter: Offset<UOffset> = Offset(),
+    mainCharacterOffset mainCharacter: Offset<UOffset> = Offset(),
-    vectorOfCharactersType charactersType: Offset<UOffset> = Offset(),
+    charactersTypeVectorOffset charactersType: Offset<UOffset> = Offset(),
-    vectorOfCharacters characters: Offset<UOffset> = Offset()
+    charactersVectorOffset characters: Offset<UOffset> = Offset()
   ) -> Offset<UOffset> {
     let __start = Movie.startMovie(&fbb)
     Movie.add(mainCharacterType: mainCharacterType, &fbb)