adds code gen for optional scalars in swift (#6038)

Adds swift test code

Replaces if statments

Adds swift to supported languages for optionals

Moved std::string to auto

Adds nullable scalars support in object api

src/idl_gen_swift.cpp

@@ -439,14 +439,16 @@ class SwiftGenerator : public BaseGenerator {
     code_ += "; return end }";
 
     if (should_generate_create) {
-      code_ +=
-          "public static func create{{STRUCTNAME}}(_ fbb: inout "
-          "FlatBufferBuilder,";
+      code_ += "public static func create{{STRUCTNAME}}(";
+      Indent();
+      code_ += "_ fbb: inout FlatBufferBuilder,";
       for (auto it = create_func_header.begin(); it < create_func_header.end();
            ++it) {
         code_ += *it + "\\";
         if (it < create_func_header.end() - 1) code_ += ",";
       }
+      code_ += "";
+      Outdent();
       code_ += ") -> Offset<UOffset> {";
       Indent();
       code_ += "let __start = {{STRUCTNAME}}.start{{STRUCTNAME}}(&fbb)";
@@ -491,8 +493,9 @@ class SwiftGenerator : public BaseGenerator {
     auto &create_func_header = *create_header;
     auto name = Name(field);
     auto type = GenType(field.value.type);
+    auto nullable_type = (field.nullable ? type + "?" : type);
     code_.SetValue("VALUENAME", name);
-    code_.SetValue("VALUETYPE", type);
+    code_.SetValue("VALUETYPE", nullable_type);
     code_.SetValue("OFFSET", name);
     code_.SetValue("CONSTANT", field.value.constant);
     std::string check_if_vector =
@@ -507,26 +510,33 @@ class SwiftGenerator : public BaseGenerator {
 
     if (IsScalar(field.value.type.base_type) &&
         !IsBool(field.value.type.base_type)) {
+      std::string is_enum = IsEnum(field.value.type) ? ".rawValue" : "";
+      code_ +=
+          "{{VALUETYPE}}" + builder_string + "fbb.add(element: {{VALUENAME}}\\";
+
+      code_ += field.nullable ? "\\" : (is_enum + ", def: {{CONSTANT}}\\");
+
+      code_ += ", at: {{TABLEOFFSET}}.{{OFFSET}}.p) }";
+
       auto default_value = IsEnum(field.value.type) ? GenEnumDefaultValue(field)
                                                     : field.value.constant;
-      auto is_enum = IsEnum(field.value.type) ? ".rawValue" : "";
-      code_ += "{{VALUETYPE}}" + builder_string +
-               "fbb.add(element: {{VALUENAME}}" + is_enum +
-               ", def: {{CONSTANT}}, at: {{TABLEOFFSET}}.{{OFFSET}}.p) }";
-      create_func_header.push_back("" + name + ": " + type + " = " +
-                                   default_value);
+      create_func_header.push_back("" + name + ": " + nullable_type + " = " +
+                                   (field.nullable ? "nil" : default_value));
       return;
     }
 
     if (IsBool(field.value.type.base_type)) {
       std::string default_value =
           "0" == field.value.constant ? "false" : "true";
-      code_.SetValue("VALUETYPE", "Bool");
+
       code_.SetValue("CONSTANT", default_value);
+      code_.SetValue("VALUETYPE", field.nullable ? "Bool?" : "Bool");
       code_ += "{{VALUETYPE}}" + builder_string +
-               "fbb.add(element: {{VALUENAME}}, def: {{CONSTANT}}, at: "
-               "{{TABLEOFFSET}}.{{OFFSET}}.p) }";
-      create_func_header.push_back(name + ": " + type + " = " + default_value);
+               "fbb.add(element: {{VALUENAME}},\\";
+      code_ += field.nullable ? "\\" : " def: {{CONSTANT}},";
+      code_ += " at: {{TABLEOFFSET}}.{{OFFSET}}.p) }";
+      create_func_header.push_back(name + ": " + nullable_type + " = " +
+                                   (field.nullable ? "nil" : default_value));
       return;
     }
 
@@ -570,11 +580,13 @@ class SwiftGenerator : public BaseGenerator {
     code_.SetValue("VALUETYPE", type);
     code_.SetValue("OFFSET", name);
     code_.SetValue("CONSTANT", field.value.constant);
-    std::string const_string = "return o == 0 ? {{CONSTANT}} : ";
+    std::string nullable = field.nullable ? "nil" : "{{CONSTANT}}";
+    std::string optional = field.nullable ? "?" : "";
+    auto const_string = "return o == 0 ? " + nullable + " : ";
     GenComment(field.doc_comment);
     if (IsScalar(field.value.type.base_type) && !IsEnum(field.value.type) &&
         !IsBool(field.value.type.base_type)) {
-      code_ += GenReaderMainBody() + GenOffset() + const_string +
+      code_ += GenReaderMainBody(optional) + GenOffset() + const_string +
                GenReader("VALUETYPE", "o") + " }";
       if (parser_.opts.mutable_buffer) code_ += GenMutate("o", GenOffset());
       return;
@@ -585,7 +597,7 @@ class SwiftGenerator : public BaseGenerator {
           "0" == field.value.constant ? "false" : "true";
       code_.SetValue("CONSTANT", default_value);
       code_.SetValue("VALUETYPE", "Bool");
-      code_ += GenReaderMainBody() + "\\";
+      code_ += GenReaderMainBody(optional) + "\\";
       code_.SetValue("VALUETYPE", "Byte");
       code_ += GenOffset() + "return o == 0 ? {{CONSTANT}} : 0 != " +
                GenReader("VALUETYPE", "o") + " }";
@@ -596,7 +608,7 @@ class SwiftGenerator : public BaseGenerator {
     if (IsEnum(field.value.type)) {
       auto default_value = GenEnumDefaultValue(field);
       code_.SetValue("BASEVALUE", GenTypeBasic(field.value.type, false));
-      code_ += GenReaderMainBody() + "\\";
+      code_ += GenReaderMainBody(optional) + "\\";
       code_ += GenOffset() + "return o == 0 ? " + default_value + " : " +
                GenEnumConstructor("o") + "?? " + default_value + " }";
       if (parser_.opts.mutable_buffer && !IsUnion(field.value.type))
@@ -1063,11 +1075,12 @@ class SwiftGenerator : public BaseGenerator {
       }
       default: {
         buffer_constructor.push_back(name + " = _t." + name);
-
+        std::string nullable = field.nullable ? "?" : "";
         if (IsScalar(field.value.type.base_type) &&
             !IsBool(field.value.type.base_type) && !IsEnum(field.value.type)) {
-          code_ += "var {{VALUENAME}}: {{VALUETYPE}}";
-          base_constructor.push_back(name + " = " + field.value.constant);
+          code_ += "var {{VALUENAME}}: {{VALUETYPE}}" + nullable;
+          if (!field.nullable)
+            base_constructor.push_back(name + " = " + field.value.constant);
           break;
         }
 
@@ -1081,10 +1094,11 @@ class SwiftGenerator : public BaseGenerator {
         }
 
         if (IsBool(field.value.type.base_type)) {
-          code_ += "var {{VALUENAME}}: Bool";
+          code_ += "var {{VALUENAME}}: Bool" + nullable;
           std::string default_value =
               "0" == field.value.constant ? "false" : "true";
-          base_constructor.push_back(name + " = " + default_value);
+          if (!field.nullable)
+            base_constructor.push_back(name + " = " + default_value);
         }
       }
     }

src/idl_parser.cpp

@@ -2258,7 +2258,7 @@ CheckedError Parser::CheckClash(std::vector<FieldDef *> &fields,
 
 
 bool Parser::SupportsNullableScalars() const {
-  return !(opts.lang_to_generate & ~IDLOptions::kRust);
+  return !(opts.lang_to_generate & ~(IDLOptions::kRust | IDLOptions::kSwift));
 }
 
 bool Parser::SupportsAdvancedUnionFeatures() const {

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

@@ -25,8 +25,10 @@ public struct HelloReply: FlatBufferObject {
     public static func startHelloReply(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
     public static func add(message: Offset<String>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: message, at: VTOFFSET.message.p)  }
     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()) -> Offset<UOffset> {
+    public static func createHelloReply(
+        _ fbb: inout FlatBufferBuilder,
+        offsetOfMessage message: Offset<String> = Offset()
+    ) -> Offset<UOffset> {
         let __start = HelloReply.startHelloReply(&fbb)
         HelloReply.add(message: message, &fbb)
         return HelloReply.endHelloReply(&fbb, start: __start)
@@ -55,8 +57,10 @@ public struct HelloRequest: FlatBufferObject {
     public static func startHelloRequest(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
     public static func add(name: Offset<String>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VTOFFSET.name.p)  }
     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()) -> Offset<UOffset> {
+    public static func createHelloRequest(
+        _ fbb: inout FlatBufferBuilder,
+        offsetOfName name: Offset<String> = Offset()
+    ) -> Offset<UOffset> {
         let __start = HelloRequest.startHelloRequest(&fbb)
         HelloRequest.add(name: name, &fbb)
         return HelloRequest.endHelloRequest(&fbb, start: __start)
@@ -88,9 +92,11 @@ public struct ManyHellosRequest: FlatBufferObject {
     public static func add(name: Offset<String>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VTOFFSET.name.p)  }
     public static func add(numGreetings: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: numGreetings, def: 0, at: VTOFFSET.numGreetings.p) }
     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(),
-    numGreetings: Int32 = 0) -> Offset<UOffset> {
+    public static func createManyHellosRequest(
+        _ fbb: inout FlatBufferBuilder,
+        offsetOfName name: Offset<String> = Offset(),
+        numGreetings: Int32 = 0
+    ) -> Offset<UOffset> {
         let __start = ManyHellosRequest.startManyHellosRequest(&fbb)
         ManyHellosRequest.add(name: name, &fbb)
         ManyHellosRequest.add(numGreetings: numGreetings, &fbb)

tests/FlatBuffers.Test.Swift/SwiftTest.sh

@@ -4,6 +4,7 @@ test_dir=`pwd`
 
 cd ${swift_dir}/Tests/FlatBuffers.Test.SwiftTests
 ${test_dir}/../flatc --swift --gen-mutable --grpc --gen-object-api -I ${test_dir}/include_test ${test_dir}/monster_test.fbs ${test_dir}/union_vector/union_vector.fbs
+${test_dir}/../flatc --swift ${test_dir}/optional_scalars.fbs
 cd ${swift_dir}
 swift build --build-tests
 swift test

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

@@ -62,23 +62,19 @@ final class FlatBuffersTests: XCTestCase {
     
     func testWriteOptionalValues() {
         var b = FlatBufferBuilder()
-        let offset = b.create(string: nil)
-        createOptionalTable(b: &b, v: nil, off: offset)
-        let unitArray = b.sizedByteArray
-        // TODO: - Test function should be adjusted when the generation of optional scalars code is complete
-        let bb = ByteBuffer(bytes: unitArray)
-        let table = Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))
-        XCTAssertEqual(unitArray, [8, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0])
-        XCTAssertEqual(table.offset(4) == 0, true)
-        XCTAssertEqual(table.offset(6) == 0, true)
-    }
-    
-    func createOptionalTable(b: inout FlatBufferBuilder, v: Int?, off: Offset<String>) {
-        let start = b.startTable(with: 2)
-        b.add(offset: off, at: 6)
-        b.add(element: v, at: 4)
-        let root = Offset<UOffset>(offset: b.endTable(at: start))
+        let root = optional_scalars.ScalarStuff.createScalarStuff(&b,
+                                                                  justI8: 80,
+                                                                  maybeI8: nil,
+                                                                  justU8: 100,
+                                                                  maybeU8: 10)
         b.finish(offset: root)
+        let scalarTable = optional_scalars.ScalarStuff.getRootAsScalarStuff(bb: b.sizedBuffer)
+        XCTAssertEqual(scalarTable.justI8, 80)
+        XCTAssertNil(scalarTable.maybeI8)
+        XCTAssertEqual(scalarTable.defaultI8, 42)
+        XCTAssertEqual(scalarTable.justU8, 100)
+        XCTAssertEqual(scalarTable.maybeU8, 10)
+        
     }
 }
 

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

@@ -54,6 +54,7 @@ extension FlatBuffersTests {
         ("testOffset", testOffset),
         ("testReadCountry", testReadCountry),
         ("testStartTable", testStartTable),
+        ("testWriteOptionalValues", testWriteOptionalValues),
     ]
 }
 

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

@@ -446,8 +446,10 @@ public struct TestSimpleTableWithEnum: FlatBufferObject {
     public static func startTestSimpleTableWithEnum(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
     public static func add(color: MyGame.Example.Color, _ fbb: inout FlatBufferBuilder) { fbb.add(element: color.rawValue, def: 2, at: VTOFFSET.color.p) }
     public static func endTestSimpleTableWithEnum(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
-    public static func createTestSimpleTableWithEnum(_ fbb: inout FlatBufferBuilder,
-    color: MyGame.Example.Color = .green) -> Offset<UOffset> {
+    public static func createTestSimpleTableWithEnum(
+        _ fbb: inout FlatBufferBuilder,
+        color: MyGame.Example.Color = .green
+    ) -> Offset<UOffset> {
         let __start = TestSimpleTableWithEnum.startTestSimpleTableWithEnum(&fbb)
         TestSimpleTableWithEnum.add(color: color, &fbb)
         return TestSimpleTableWithEnum.endTestSimpleTableWithEnum(&fbb, start: __start)
@@ -513,10 +515,12 @@ public struct Stat: FlatBufferObject {
     public static func add(val: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: val, def: 0, at: VTOFFSET.val.p) }
     public static func add(count: UInt16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: count, def: 0, at: VTOFFSET.count.p) }
     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(),
-    val: Int64 = 0,
-    count: UInt16 = 0) -> Offset<UOffset> {
+    public static func createStat(
+        _ fbb: inout FlatBufferBuilder,
+        offsetOfId id: Offset<String> = Offset(),
+        val: Int64 = 0,
+        count: UInt16 = 0
+    ) -> Offset<UOffset> {
         let __start = Stat.startStat(&fbb)
         Stat.add(id: id, &fbb)
         Stat.add(val: val, &fbb)
@@ -590,8 +594,10 @@ public struct Referrable: FlatBufferObject {
     public static func startReferrable(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
     public static func add(id: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: id, def: 0, at: VTOFFSET.id.p) }
     public static func endReferrable(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
-    public static func createReferrable(_ fbb: inout FlatBufferBuilder,
-    id: UInt64 = 0) -> Offset<UOffset> {
+    public static func createReferrable(
+        _ fbb: inout FlatBufferBuilder,
+        id: UInt64 = 0
+    ) -> Offset<UOffset> {
         let __start = Referrable.startReferrable(&fbb)
         Referrable.add(id: id, &fbb)
         return Referrable.endReferrable(&fbb, start: __start)
@@ -840,7 +846,8 @@ public struct Monster: FlatBufferObject {
     public static func add(enemy: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: enemy, at: VTOFFSET.enemy.p)  }
     public static func addVectorOf(testnestedflatbuffer: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testnestedflatbuffer, at: VTOFFSET.testnestedflatbuffer.p)  }
     public static func add(testempty: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: testempty, at: VTOFFSET.testempty.p)  }
-    public static func add(testbool: Bool, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testbool, def: false, at: VTOFFSET.testbool.p) }
+    public static func add(testbool: Bool, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testbool, def: false,
+     at: VTOFFSET.testbool.p) }
     public static func add(testhashs32Fnv1: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashs32Fnv1, def: 0, at: VTOFFSET.testhashs32Fnv1.p) }
     public static func add(testhashu32Fnv1: UInt32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashu32Fnv1, def: 0, at: VTOFFSET.testhashu32Fnv1.p) }
     public static func add(testhashs64Fnv1: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: testhashs64Fnv1, def: 0, at: VTOFFSET.testhashs64Fnv1.p) }
@@ -875,55 +882,57 @@ public struct Monster: FlatBufferObject {
     public static func addVectorOf(vectorOfEnums: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vectorOfEnums, at: VTOFFSET.vectorOfEnums.p)  }
     public static func add(signedEnum: MyGame.Example.Race, _ fbb: inout FlatBufferBuilder) { fbb.add(element: signedEnum.rawValue, def: -1, at: VTOFFSET.signedEnum.p) }
     public static func endMonster(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); fbb.require(table: end, fields: [10]); return end }
-    public static func createMonster(_ fbb: inout FlatBufferBuilder,
-    structOfPos pos: UnsafeMutableRawPointer? = nil,
-    mana: Int16 = 150,
-    hp: Int16 = 100,
-    offsetOfName name: Offset<String> = Offset(),
-    vectorOfInventory inventory: Offset<UOffset> = Offset(),
-    color: MyGame.Example.Color = .blue,
-    testType: MyGame.Example.Any_ = .none_,
-    offsetOfTest test: Offset<UOffset> = Offset(),
-    vectorOfTest4 test4: Offset<UOffset> = Offset(),
-    vectorOfTestarrayofstring testarrayofstring: Offset<UOffset> = Offset(),
-    vectorOfTestarrayoftables testarrayoftables: Offset<UOffset> = Offset(),
-    offsetOfEnemy enemy: Offset<UOffset> = Offset(),
-    vectorOfTestnestedflatbuffer testnestedflatbuffer: Offset<UOffset> = Offset(),
-    offsetOfTestempty testempty: Offset<UOffset> = Offset(),
-    testbool: Bool = false,
-    testhashs32Fnv1: Int32 = 0,
-    testhashu32Fnv1: UInt32 = 0,
-    testhashs64Fnv1: Int64 = 0,
-    testhashu64Fnv1: UInt64 = 0,
-    testhashs32Fnv1a: Int32 = 0,
-    testhashu32Fnv1a: UInt32 = 0,
-    testhashs64Fnv1a: Int64 = 0,
-    testhashu64Fnv1a: UInt64 = 0,
-    vectorOfTestarrayofbools testarrayofbools: Offset<UOffset> = Offset(),
-    testf: Float32 = 3.14159,
-    testf2: Float32 = 3.0,
-    testf3: Float32 = 0.0,
-    vectorOfTestarrayofstring2 testarrayofstring2: Offset<UOffset> = Offset(),
-    vectorOfTestarrayofsortedstruct testarrayofsortedstruct: Offset<UOffset> = Offset(),
-    vectorOfFlex flex: Offset<UOffset> = Offset(),
-    vectorOfTest5 test5: Offset<UOffset> = Offset(),
-    vectorOfVectorOfLongs vectorOfLongs: Offset<UOffset> = Offset(),
-    vectorOfVectorOfDoubles vectorOfDoubles: Offset<UOffset> = Offset(),
-    offsetOfParentNamespaceTest parentNamespaceTest: Offset<UOffset> = Offset(),
-    vectorOfVectorOfReferrables vectorOfReferrables: Offset<UOffset> = Offset(),
-    singleWeakReference: UInt64 = 0,
-    vectorOfVectorOfWeakReferences vectorOfWeakReferences: Offset<UOffset> = Offset(),
-    vectorOfVectorOfStrongReferrables vectorOfStrongReferrables: Offset<UOffset> = Offset(),
-    coOwningReference: UInt64 = 0,
-    vectorOfVectorOfCoOwningReferences vectorOfCoOwningReferences: Offset<UOffset> = Offset(),
-    nonOwningReference: UInt64 = 0,
-    vectorOfVectorOfNonOwningReferences vectorOfNonOwningReferences: Offset<UOffset> = Offset(),
-    anyUniqueType: MyGame.Example.AnyUniqueAliases = .none_,
-    offsetOfAnyUnique anyUnique: Offset<UOffset> = Offset(),
-    anyAmbiguousType: MyGame.Example.AnyAmbiguousAliases = .none_,
-    offsetOfAnyAmbiguous anyAmbiguous: Offset<UOffset> = Offset(),
-    vectorOfVectorOfEnums vectorOfEnums: Offset<UOffset> = Offset(),
-    signedEnum: MyGame.Example.Race = .none_) -> Offset<UOffset> {
+    public static func createMonster(
+        _ fbb: inout FlatBufferBuilder,
+        structOfPos pos: UnsafeMutableRawPointer? = nil,
+        mana: Int16 = 150,
+        hp: Int16 = 100,
+        offsetOfName name: Offset<String> = Offset(),
+        vectorOfInventory inventory: Offset<UOffset> = Offset(),
+        color: MyGame.Example.Color = .blue,
+        testType: MyGame.Example.Any_ = .none_,
+        offsetOfTest test: Offset<UOffset> = Offset(),
+        vectorOfTest4 test4: Offset<UOffset> = Offset(),
+        vectorOfTestarrayofstring testarrayofstring: Offset<UOffset> = Offset(),
+        vectorOfTestarrayoftables testarrayoftables: Offset<UOffset> = Offset(),
+        offsetOfEnemy enemy: Offset<UOffset> = Offset(),
+        vectorOfTestnestedflatbuffer testnestedflatbuffer: Offset<UOffset> = Offset(),
+        offsetOfTestempty testempty: Offset<UOffset> = Offset(),
+        testbool: Bool = false,
+        testhashs32Fnv1: Int32 = 0,
+        testhashu32Fnv1: UInt32 = 0,
+        testhashs64Fnv1: Int64 = 0,
+        testhashu64Fnv1: UInt64 = 0,
+        testhashs32Fnv1a: Int32 = 0,
+        testhashu32Fnv1a: UInt32 = 0,
+        testhashs64Fnv1a: Int64 = 0,
+        testhashu64Fnv1a: UInt64 = 0,
+        vectorOfTestarrayofbools testarrayofbools: Offset<UOffset> = Offset(),
+        testf: Float32 = 3.14159,
+        testf2: Float32 = 3.0,
+        testf3: Float32 = 0.0,
+        vectorOfTestarrayofstring2 testarrayofstring2: Offset<UOffset> = Offset(),
+        vectorOfTestarrayofsortedstruct testarrayofsortedstruct: Offset<UOffset> = Offset(),
+        vectorOfFlex flex: Offset<UOffset> = Offset(),
+        vectorOfTest5 test5: Offset<UOffset> = Offset(),
+        vectorOfVectorOfLongs vectorOfLongs: Offset<UOffset> = Offset(),
+        vectorOfVectorOfDoubles vectorOfDoubles: Offset<UOffset> = Offset(),
+        offsetOfParentNamespaceTest parentNamespaceTest: Offset<UOffset> = Offset(),
+        vectorOfVectorOfReferrables vectorOfReferrables: Offset<UOffset> = Offset(),
+        singleWeakReference: UInt64 = 0,
+        vectorOfVectorOfWeakReferences vectorOfWeakReferences: Offset<UOffset> = Offset(),
+        vectorOfVectorOfStrongReferrables vectorOfStrongReferrables: Offset<UOffset> = Offset(),
+        coOwningReference: UInt64 = 0,
+        vectorOfVectorOfCoOwningReferences vectorOfCoOwningReferences: Offset<UOffset> = Offset(),
+        nonOwningReference: UInt64 = 0,
+        vectorOfVectorOfNonOwningReferences vectorOfNonOwningReferences: Offset<UOffset> = Offset(),
+        anyUniqueType: MyGame.Example.AnyUniqueAliases = .none_,
+        offsetOfAnyUnique anyUnique: Offset<UOffset> = Offset(),
+        anyAmbiguousType: MyGame.Example.AnyAmbiguousAliases = .none_,
+        offsetOfAnyAmbiguous anyAmbiguous: Offset<UOffset> = Offset(),
+        vectorOfVectorOfEnums vectorOfEnums: Offset<UOffset> = Offset(),
+        signedEnum: MyGame.Example.Race = .none_
+    ) -> Offset<UOffset> {
         let __start = Monster.startMonster(&fbb)
         Monster.add(pos: pos, &fbb)
         Monster.add(mana: mana, &fbb)
@@ -1436,19 +1445,21 @@ public struct TypeAliases: FlatBufferObject {
     public static func addVectorOf(v8: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: v8, at: VTOFFSET.v8.p)  }
     public static func addVectorOf(vf64: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: vf64, at: VTOFFSET.vf64.p)  }
     public static func endTypeAliases(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
-    public static func createTypeAliases(_ fbb: inout FlatBufferBuilder,
-    i8: Int8 = 0,
-    u8: UInt8 = 0,
-    i16: Int16 = 0,
-    u16: UInt16 = 0,
-    i32: Int32 = 0,
-    u32: UInt32 = 0,
-    i64: Int64 = 0,
-    u64: UInt64 = 0,
-    f32: Float32 = 0.0,
-    f64: Double = 0.0,
-    vectorOfV8 v8: Offset<UOffset> = Offset(),
-    vectorOfVf64 vf64: Offset<UOffset> = Offset()) -> Offset<UOffset> {
+    public static func createTypeAliases(
+        _ fbb: inout FlatBufferBuilder,
+        i8: Int8 = 0,
+        u8: UInt8 = 0,
+        i16: Int16 = 0,
+        u16: UInt16 = 0,
+        i32: Int32 = 0,
+        u32: UInt32 = 0,
+        i64: Int64 = 0,
+        u64: UInt64 = 0,
+        f32: Float32 = 0.0,
+        f64: Double = 0.0,
+        vectorOfV8 v8: Offset<UOffset> = Offset(),
+        vectorOfVf64 vf64: Offset<UOffset> = Offset()
+    ) -> Offset<UOffset> {
         let __start = TypeAliases.startTypeAliases(&fbb)
         TypeAliases.add(i8: i8, &fbb)
         TypeAliases.add(u8: u8, &fbb)

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

@@ -0,0 +1,205 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// swiftlint:disable all
+
+import FlatBuffers
+
+public enum optional_scalars {
+
+public struct ScalarStuff: FlatBufferObject {
+
+    static func validateVersion() { FlatBuffersVersion_1_12_0() }
+    public var __buffer: ByteBuffer! { return _accessor.bb }
+    private var _accessor: Table
+
+    public static func getRootAsScalarStuff(bb: ByteBuffer) -> ScalarStuff { return ScalarStuff(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
+
+    private init(_ t: Table) { _accessor = t }
+    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
+
+    enum VTOFFSET: VOffset {
+        case justI8 = 4
+        case maybeI8 = 6
+        case defaultI8 = 8
+        case justU8 = 10
+        case maybeU8 = 12
+        case defaultU8 = 14
+        case justI16 = 16
+        case maybeI16 = 18
+        case defaultI16 = 20
+        case justU16 = 22
+        case maybeU16 = 24
+        case defaultU16 = 26
+        case justI32 = 28
+        case maybeI32 = 30
+        case defaultI32 = 32
+        case justU32 = 34
+        case maybeU32 = 36
+        case defaultU32 = 38
+        case justI64 = 40
+        case maybeI64 = 42
+        case defaultI64 = 44
+        case justU64 = 46
+        case maybeU64 = 48
+        case defaultU64 = 50
+        case justF32 = 52
+        case maybeF32 = 54
+        case defaultF32 = 56
+        case justF64 = 58
+        case maybeF64 = 60
+        case defaultF64 = 62
+        case justBool = 64
+        case maybeBool = 66
+        case defaultBool = 68
+        var v: Int32 { Int32(self.rawValue) }
+        var p: VOffset { self.rawValue }
+    }
+
+    public var justI8: Int8 { let o = _accessor.offset(VTOFFSET.justI8.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int8.self, at: o) }
+    public var maybeI8: Int8? { let o = _accessor.offset(VTOFFSET.maybeI8.v); return o == 0 ? nil : _accessor.readBuffer(of: Int8.self, at: o) }
+    public var defaultI8: Int8 { let o = _accessor.offset(VTOFFSET.defaultI8.v); return o == 0 ? 42 : _accessor.readBuffer(of: Int8.self, at: o) }
+    public var justU8: UInt8 { let o = _accessor.offset(VTOFFSET.justU8.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt8.self, at: o) }
+    public var maybeU8: UInt8? { let o = _accessor.offset(VTOFFSET.maybeU8.v); return o == 0 ? nil : _accessor.readBuffer(of: UInt8.self, at: o) }
+    public var defaultU8: UInt8 { let o = _accessor.offset(VTOFFSET.defaultU8.v); return o == 0 ? 42 : _accessor.readBuffer(of: UInt8.self, at: o) }
+    public var justI16: Int16 { let o = _accessor.offset(VTOFFSET.justI16.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int16.self, at: o) }
+    public var maybeI16: Int16? { let o = _accessor.offset(VTOFFSET.maybeI16.v); return o == 0 ? nil : _accessor.readBuffer(of: Int16.self, at: o) }
+    public var defaultI16: Int16 { let o = _accessor.offset(VTOFFSET.defaultI16.v); return o == 0 ? 42 : _accessor.readBuffer(of: Int16.self, at: o) }
+    public var justU16: UInt16 { let o = _accessor.offset(VTOFFSET.justU16.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt16.self, at: o) }
+    public var maybeU16: UInt16? { let o = _accessor.offset(VTOFFSET.maybeU16.v); return o == 0 ? nil : _accessor.readBuffer(of: UInt16.self, at: o) }
+    public var defaultU16: UInt16 { let o = _accessor.offset(VTOFFSET.defaultU16.v); return o == 0 ? 42 : _accessor.readBuffer(of: UInt16.self, at: o) }
+    public var justI32: Int32 { let o = _accessor.offset(VTOFFSET.justI32.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int32.self, at: o) }
+    public var maybeI32: Int32? { let o = _accessor.offset(VTOFFSET.maybeI32.v); return o == 0 ? nil : _accessor.readBuffer(of: Int32.self, at: o) }
+    public var defaultI32: Int32 { let o = _accessor.offset(VTOFFSET.defaultI32.v); return o == 0 ? 42 : _accessor.readBuffer(of: Int32.self, at: o) }
+    public var justU32: UInt32 { let o = _accessor.offset(VTOFFSET.justU32.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt32.self, at: o) }
+    public var maybeU32: UInt32? { let o = _accessor.offset(VTOFFSET.maybeU32.v); return o == 0 ? nil : _accessor.readBuffer(of: UInt32.self, at: o) }
+    public var defaultU32: UInt32 { let o = _accessor.offset(VTOFFSET.defaultU32.v); return o == 0 ? 42 : _accessor.readBuffer(of: UInt32.self, at: o) }
+    public var justI64: Int64 { let o = _accessor.offset(VTOFFSET.justI64.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int64.self, at: o) }
+    public var maybeI64: Int64? { let o = _accessor.offset(VTOFFSET.maybeI64.v); return o == 0 ? nil : _accessor.readBuffer(of: Int64.self, at: o) }
+    public var defaultI64: Int64 { let o = _accessor.offset(VTOFFSET.defaultI64.v); return o == 0 ? 42 : _accessor.readBuffer(of: Int64.self, at: o) }
+    public var justU64: UInt64 { let o = _accessor.offset(VTOFFSET.justU64.v); return o == 0 ? 0 : _accessor.readBuffer(of: UInt64.self, at: o) }
+    public var maybeU64: UInt64? { let o = _accessor.offset(VTOFFSET.maybeU64.v); return o == 0 ? nil : _accessor.readBuffer(of: UInt64.self, at: o) }
+    public var defaultU64: UInt64 { let o = _accessor.offset(VTOFFSET.defaultU64.v); return o == 0 ? 42 : _accessor.readBuffer(of: UInt64.self, at: o) }
+    public var justF32: Float32 { let o = _accessor.offset(VTOFFSET.justF32.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Float32.self, at: o) }
+    public var maybeF32: Float32? { let o = _accessor.offset(VTOFFSET.maybeF32.v); return o == 0 ? nil : _accessor.readBuffer(of: Float32.self, at: o) }
+    public var defaultF32: Float32 { let o = _accessor.offset(VTOFFSET.defaultF32.v); return o == 0 ? 42.0 : _accessor.readBuffer(of: Float32.self, at: o) }
+    public var justF64: Double { let o = _accessor.offset(VTOFFSET.justF64.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
+    public var maybeF64: Double? { let o = _accessor.offset(VTOFFSET.maybeF64.v); return o == 0 ? nil : _accessor.readBuffer(of: Double.self, at: o) }
+    public var defaultF64: Double { let o = _accessor.offset(VTOFFSET.defaultF64.v); return o == 0 ? 42.0 : _accessor.readBuffer(of: Double.self, at: o) }
+    public var justBool: Bool { let o = _accessor.offset(VTOFFSET.justBool.v); return o == 0 ? false : 0 != _accessor.readBuffer(of: Byte.self, at: o) }
+    public var maybeBool: Bool? { let o = _accessor.offset(VTOFFSET.maybeBool.v); return o == 0 ? true : 0 != _accessor.readBuffer(of: Byte.self, at: o) }
+    public var defaultBool: Bool { let o = _accessor.offset(VTOFFSET.defaultBool.v); return o == 0 ? true : 0 != _accessor.readBuffer(of: Byte.self, at: o) }
+    public static func startScalarStuff(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 33) }
+    public static func add(justI8: Int8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justI8, def: 0, at: VTOFFSET.justI8.p) }
+    public static func add(maybeI8: Int8?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeI8, at: VTOFFSET.maybeI8.p) }
+    public static func add(defaultI8: Int8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultI8, def: 42, at: VTOFFSET.defaultI8.p) }
+    public static func add(justU8: UInt8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justU8, def: 0, at: VTOFFSET.justU8.p) }
+    public static func add(maybeU8: UInt8?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeU8, at: VTOFFSET.maybeU8.p) }
+    public static func add(defaultU8: UInt8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultU8, def: 42, at: VTOFFSET.defaultU8.p) }
+    public static func add(justI16: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justI16, def: 0, at: VTOFFSET.justI16.p) }
+    public static func add(maybeI16: Int16?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeI16, at: VTOFFSET.maybeI16.p) }
+    public static func add(defaultI16: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultI16, def: 42, at: VTOFFSET.defaultI16.p) }
+    public static func add(justU16: UInt16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justU16, def: 0, at: VTOFFSET.justU16.p) }
+    public static func add(maybeU16: UInt16?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeU16, at: VTOFFSET.maybeU16.p) }
+    public static func add(defaultU16: UInt16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultU16, def: 42, at: VTOFFSET.defaultU16.p) }
+    public static func add(justI32: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justI32, def: 0, at: VTOFFSET.justI32.p) }
+    public static func add(maybeI32: Int32?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeI32, at: VTOFFSET.maybeI32.p) }
+    public static func add(defaultI32: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultI32, def: 42, at: VTOFFSET.defaultI32.p) }
+    public static func add(justU32: UInt32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justU32, def: 0, at: VTOFFSET.justU32.p) }
+    public static func add(maybeU32: UInt32?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeU32, at: VTOFFSET.maybeU32.p) }
+    public static func add(defaultU32: UInt32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultU32, def: 42, at: VTOFFSET.defaultU32.p) }
+    public static func add(justI64: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justI64, def: 0, at: VTOFFSET.justI64.p) }
+    public static func add(maybeI64: Int64?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeI64, at: VTOFFSET.maybeI64.p) }
+    public static func add(defaultI64: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultI64, def: 42, at: VTOFFSET.defaultI64.p) }
+    public static func add(justU64: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justU64, def: 0, at: VTOFFSET.justU64.p) }
+    public static func add(maybeU64: UInt64?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeU64, at: VTOFFSET.maybeU64.p) }
+    public static func add(defaultU64: UInt64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultU64, def: 42, at: VTOFFSET.defaultU64.p) }
+    public static func add(justF32: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justF32, def: 0.0, at: VTOFFSET.justF32.p) }
+    public static func add(maybeF32: Float32?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeF32, at: VTOFFSET.maybeF32.p) }
+    public static func add(defaultF32: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultF32, def: 42.0, at: VTOFFSET.defaultF32.p) }
+    public static func add(justF64: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justF64, def: 0.0, at: VTOFFSET.justF64.p) }
+    public static func add(maybeF64: Double?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeF64, at: VTOFFSET.maybeF64.p) }
+    public static func add(defaultF64: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultF64, def: 42.0, at: VTOFFSET.defaultF64.p) }
+    public static func add(justBool: Bool, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justBool, def: false,
+     at: VTOFFSET.justBool.p) }
+    public static func add(maybeBool: Bool?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeBool, at: VTOFFSET.maybeBool.p) }
+    public static func add(defaultBool: Bool, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultBool, def: true,
+     at: VTOFFSET.defaultBool.p) }
+    public static func endScalarStuff(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
+    public static func createScalarStuff(
+        _ fbb: inout FlatBufferBuilder,
+        justI8: Int8 = 0,
+        maybeI8: Int8? = nil,
+        defaultI8: Int8 = 42,
+        justU8: UInt8 = 0,
+        maybeU8: UInt8? = nil,
+        defaultU8: UInt8 = 42,
+        justI16: Int16 = 0,
+        maybeI16: Int16? = nil,
+        defaultI16: Int16 = 42,
+        justU16: UInt16 = 0,
+        maybeU16: UInt16? = nil,
+        defaultU16: UInt16 = 42,
+        justI32: Int32 = 0,
+        maybeI32: Int32? = nil,
+        defaultI32: Int32 = 42,
+        justU32: UInt32 = 0,
+        maybeU32: UInt32? = nil,
+        defaultU32: UInt32 = 42,
+        justI64: Int64 = 0,
+        maybeI64: Int64? = nil,
+        defaultI64: Int64 = 42,
+        justU64: UInt64 = 0,
+        maybeU64: UInt64? = nil,
+        defaultU64: UInt64 = 42,
+        justF32: Float32 = 0.0,
+        maybeF32: Float32? = nil,
+        defaultF32: Float32 = 42.0,
+        justF64: Double = 0.0,
+        maybeF64: Double? = nil,
+        defaultF64: Double = 42.0,
+        justBool: Bool = false,
+        maybeBool: Bool? = nil,
+        defaultBool: Bool = true
+    ) -> Offset<UOffset> {
+        let __start = ScalarStuff.startScalarStuff(&fbb)
+        ScalarStuff.add(justI8: justI8, &fbb)
+        ScalarStuff.add(maybeI8: maybeI8, &fbb)
+        ScalarStuff.add(defaultI8: defaultI8, &fbb)
+        ScalarStuff.add(justU8: justU8, &fbb)
+        ScalarStuff.add(maybeU8: maybeU8, &fbb)
+        ScalarStuff.add(defaultU8: defaultU8, &fbb)
+        ScalarStuff.add(justI16: justI16, &fbb)
+        ScalarStuff.add(maybeI16: maybeI16, &fbb)
+        ScalarStuff.add(defaultI16: defaultI16, &fbb)
+        ScalarStuff.add(justU16: justU16, &fbb)
+        ScalarStuff.add(maybeU16: maybeU16, &fbb)
+        ScalarStuff.add(defaultU16: defaultU16, &fbb)
+        ScalarStuff.add(justI32: justI32, &fbb)
+        ScalarStuff.add(maybeI32: maybeI32, &fbb)
+        ScalarStuff.add(defaultI32: defaultI32, &fbb)
+        ScalarStuff.add(justU32: justU32, &fbb)
+        ScalarStuff.add(maybeU32: maybeU32, &fbb)
+        ScalarStuff.add(defaultU32: defaultU32, &fbb)
+        ScalarStuff.add(justI64: justI64, &fbb)
+        ScalarStuff.add(maybeI64: maybeI64, &fbb)
+        ScalarStuff.add(defaultI64: defaultI64, &fbb)
+        ScalarStuff.add(justU64: justU64, &fbb)
+        ScalarStuff.add(maybeU64: maybeU64, &fbb)
+        ScalarStuff.add(defaultU64: defaultU64, &fbb)
+        ScalarStuff.add(justF32: justF32, &fbb)
+        ScalarStuff.add(maybeF32: maybeF32, &fbb)
+        ScalarStuff.add(defaultF32: defaultF32, &fbb)
+        ScalarStuff.add(justF64: justF64, &fbb)
+        ScalarStuff.add(maybeF64: maybeF64, &fbb)
+        ScalarStuff.add(defaultF64: defaultF64, &fbb)
+        ScalarStuff.add(justBool: justBool, &fbb)
+        ScalarStuff.add(maybeBool: maybeBool, &fbb)
+        ScalarStuff.add(defaultBool: defaultBool, &fbb)
+        return ScalarStuff.endScalarStuff(&fbb, start: __start)
+    }
+}
+
+}
+
+// MARK: - optional_scalars
+
+

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

@@ -162,8 +162,10 @@ public struct Attacker: FlatBufferObject {
     public static func startAttacker(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
     public static func add(swordAttackDamage: Int32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: swordAttackDamage, def: 0, at: VTOFFSET.swordAttackDamage.p) }
     public static func endAttacker(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
-    public static func createAttacker(_ fbb: inout FlatBufferBuilder,
-    swordAttackDamage: Int32 = 0) -> Offset<UOffset> {
+    public static func createAttacker(
+        _ fbb: inout FlatBufferBuilder,
+        swordAttackDamage: Int32 = 0
+    ) -> Offset<UOffset> {
         let __start = Attacker.startAttacker(&fbb)
         Attacker.add(swordAttackDamage: swordAttackDamage, &fbb)
         return Attacker.endAttacker(&fbb, start: __start)
@@ -231,11 +233,13 @@ public struct Movie: FlatBufferObject {
     public static func addVectorOf(charactersType: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: charactersType, at: VTOFFSET.charactersType.p)  }
     public static func addVectorOf(characters: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: characters, at: VTOFFSET.characters.p)  }
     public static func endMovie(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
-    public static func createMovie(_ fbb: inout FlatBufferBuilder,
-    mainCharacterType: Character = .none_,
-    offsetOfMainCharacter mainCharacter: Offset<UOffset> = Offset(),
-    vectorOfCharactersType charactersType: Offset<UOffset> = Offset(),
-    vectorOfCharacters characters: Offset<UOffset> = Offset()) -> Offset<UOffset> {
+    public static func createMovie(
+        _ fbb: inout FlatBufferBuilder,
+        mainCharacterType: Character = .none_,
+        offsetOfMainCharacter mainCharacter: Offset<UOffset> = Offset(),
+        vectorOfCharactersType charactersType: Offset<UOffset> = Offset(),
+        vectorOfCharacters characters: Offset<UOffset> = Offset()
+    ) -> Offset<UOffset> {
         let __start = Movie.startMovie(&fbb)
         Movie.add(mainCharacterType: mainCharacterType, &fbb)
         Movie.add(mainCharacter: mainCharacter, &fbb)

tests/generate_code.sh

@@ -61,6 +61,7 @@ working_dir=`pwd`
 cd FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests
 $working_dir/../flatc --swift --grpc $TEST_NOINCL_FLAGS $TEST_CPP_FLAGS $TEST_CS_FLAGS -I ../../../include_test ../../../monster_test.fbs
 $working_dir/../flatc --swift $TEST_BASE_FLAGS $TEST_CPP_FLAGS $TEST_CS_FLAGS ../../../union_vector/union_vector.fbs
+$working_dir/../flatc --swift ../../../optional_scalars.fbs
 cd $working_dir
 
 cd FlatBuffers.GRPC.Swift/Sources/Model

tests/test.cpp

@@ -3457,7 +3457,7 @@ void NullableScalarsTest() {
 
   // Test if nullable scalars are allowed for each language.
   const int kNumLanguages = 17;
-  const auto supported = flatbuffers::IDLOptions::kRust;
+  const auto supported = (flatbuffers::IDLOptions::kRust | flatbuffers::IDLOptions::kSwift);
   for (int lang=0; lang<kNumLanguages; lang++) {
     flatbuffers::IDLOptions opts;
     opts.lang_to_generate |= 1 << lang;