Default-empty vectors of enums

src/idl_gen_swift.cpp

@@ -847,7 +847,7 @@ class SwiftGenerator : public BaseGenerator {
     code_.SetValue("ENUM_NAME", NameWrappedInNameSpace(enum_def));
     code_.SetValue("BASE_TYPE", GenTypeBasic(enum_def.underlying_type, false));
     GenComment(enum_def.doc_comment);
-    code_ += "{{ACCESS_TYPE}} enum {{ENUM_NAME}}: {{BASE_TYPE}}, Enum { ";
+    code_ += "{{ACCESS_TYPE}} enum {{ENUM_NAME}}: {{BASE_TYPE}}, Enum {";
     Indent();
     code_ += "{{ACCESS_TYPE}} typealias T = {{BASE_TYPE}}";
     code_ +=
@@ -1471,7 +1471,9 @@ class SwiftGenerator : public BaseGenerator {
     auto &value = field.value;
     FLATBUFFERS_ASSERT(value.type.enum_def);
     auto &enum_def = *value.type.enum_def;
-    auto enum_val = enum_def.FindByValue(value.constant);
+    // Vector of enum defaults are always "[]" which never works.
+    const std::string constant = IsVector(value.type) ? "0" : value.constant;
+    auto enum_val = enum_def.FindByValue(constant);
     std::string name;
     if (enum_val) {
       name = Name(*enum_val);

src/idl_parser.cpp

@@ -906,24 +906,32 @@ CheckedError Parser::ParseField(StructDef &struct_def) {
   }
 
   if (type.enum_def) {
-    // The type.base_type can only be scalar, union, array or vector.
-    // Table, struct or string can't have enum_def.
-    // Default value of union and vector in NONE, NULL translated to "0".
-    FLATBUFFERS_ASSERT(IsInteger(type.base_type) ||
-                       (type.base_type == BASE_TYPE_UNION) || IsVector(type) ||
-                       IsArray(type));
-    if (IsVector(type)) {
-      // Vector can't use initialization list.
-      FLATBUFFERS_ASSERT(field->value.constant == "0");
+    // Verify the enum's type and default value.
+    const std::string &constant = field->value.constant;
+    if (type.base_type == BASE_TYPE_UNION) {
+      if (constant != "0") { return Error("Union defaults must be NONE"); }
+    } else if (IsVector(type)) {
+      if (constant != "0" && constant != "[]") {
+        return Error("Vector defaults may only be `[]`.");
+      }
+    } else if (IsArray(type)) {
+      if (constant != "0") {
+        return Error("Array defaults are not supported yet.");
+      }
     } else {
-      // All unions should have the NONE ("0") enum value.
-      auto in_enum = field->IsOptional() ||
-                     type.enum_def->attributes.Lookup("bit_flags") ||
-                     type.enum_def->FindByValue(field->value.constant);
-      if (false == in_enum)
-        return Error("default value of " + field->value.constant +
-                     " for field " + name + " is not part of enum " +
-                     type.enum_def->name);
+      if (!IsInteger(type.base_type)) {
+        return Error("Enums must have integer base types");
+      }
+      // Optional and bitflags enums may have default constants that are not
+      // their specified variants.
+      if (!field->IsOptional() &&
+          type.enum_def->attributes.Lookup("bit_flags") == nullptr) {
+        if (type.enum_def->FindByValue(constant) == nullptr) {
+          return Error("default value of `" + constant + "` for " + "field `" +
+                       name + "` is not part of enum `" +
+                       type.enum_def->name + "`.");
+        }
+      }
     }
   }
 

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

@@ -29,8 +29,14 @@ class FlatBuffersMoreDefaults: XCTestCase {
     XCTAssertEqual(defaults.someString, "some")
     XCTAssertEqual(defaults.ints, [])
     XCTAssertEqual(defaults.floats, [])
+    XCTAssertEqual(defaults.abcs, [])
+    XCTAssertEqual(defaults.voids, [])
+    XCTAssertEqual(defaults.bools, [])
     XCTAssertEqual(defaults.intsCount, 0)
     XCTAssertEqual(defaults.floatsCount, 0)
+    XCTAssertEqual(defaults.abcsCount, 0)
+    XCTAssertEqual(defaults.voidsCount, 0)
+    XCTAssertEqual(defaults.boolsCount, 0)
   }
 
   func testFlatbuffersObjectAPI() {
@@ -40,6 +46,9 @@ class FlatBuffersMoreDefaults: XCTestCase {
     XCTAssertEqual(defaults.someString, "some")
     XCTAssertEqual(defaults.ints, [])
     XCTAssertEqual(defaults.floats, [])
+    XCTAssertEqual(defaults.abcs, [])
+    XCTAssertEqual(defaults.voids, [])
+    XCTAssertEqual(defaults.bools, [])
 
     let buffer = defaults.serialize(builder: &fbb, type: MoreDefaults.self)
     let fDefaults = MoreDefaults.getRootAsMoreDefaults(bb: buffer)
@@ -49,5 +58,8 @@ class FlatBuffersMoreDefaults: XCTestCase {
     XCTAssertEqual(fDefaults.floats, [])
     XCTAssertEqual(fDefaults.intsCount, 0)
     XCTAssertEqual(fDefaults.floatsCount, 0)
+    XCTAssertEqual(fDefaults.abcsCount, 0)
+    XCTAssertEqual(fDefaults.voidsCount, 0)
+    XCTAssertEqual(fDefaults.boolsCount, 0)
   }
 }

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

@@ -5,7 +5,7 @@
 import FlatBuffers
 
 ///  Composite components of Monster color.
-public enum MyGame_Example_Color: UInt8, Enum { 
+public enum MyGame_Example_Color: UInt8, Enum {
   public typealias T = UInt8
   public static var byteSize: Int { return MemoryLayout<UInt8>.size }
   public var value: UInt8 { return self.rawValue }
@@ -21,7 +21,7 @@ public enum MyGame_Example_Color: UInt8, Enum {
   public static var min: MyGame_Example_Color { return .red }
 }
 
-public enum MyGame_Example_Race: Int8, Enum { 
+public enum MyGame_Example_Race: Int8, Enum {
   public typealias T = Int8
   public static var byteSize: Int { return MemoryLayout<Int8>.size }
   public var value: Int8 { return self.rawValue }
@@ -35,7 +35,7 @@ public enum MyGame_Example_Race: Int8, Enum {
   public static var min: MyGame_Example_Race { return .none_ }
 }
 
-public enum MyGame_Example_Any_: UInt8, Enum { 
+public enum MyGame_Example_Any_: UInt8, Enum {
   public typealias T = UInt8
   public static var byteSize: Int { return MemoryLayout<UInt8>.size }
   public var value: UInt8 { return self.rawValue }
@@ -71,7 +71,7 @@ public struct MyGame_Example_Any_Union {
     }
   }
 }
-public enum MyGame_Example_AnyUniqueAliases: UInt8, Enum { 
+public enum MyGame_Example_AnyUniqueAliases: UInt8, Enum {
   public typealias T = UInt8
   public static var byteSize: Int { return MemoryLayout<UInt8>.size }
   public var value: UInt8 { return self.rawValue }
@@ -107,7 +107,7 @@ public struct MyGame_Example_AnyUniqueAliasesUnion {
     }
   }
 }
-public enum MyGame_Example_AnyAmbiguousAliases: UInt8, Enum { 
+public enum MyGame_Example_AnyAmbiguousAliases: UInt8, Enum {
   public typealias T = UInt8
   public static var byteSize: Int { return MemoryLayout<UInt8>.size }
   public var value: UInt8 { return self.rawValue }

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

@@ -4,6 +4,30 @@
 
 import FlatBuffers
 
+public enum ABC: Int32, Enum {
+  public typealias T = Int32
+  public static var byteSize: Int { return MemoryLayout<Int32>.size }
+  public var value: Int32 { return self.rawValue }
+  case a = 0
+  case b = 1
+  case c = 2
+
+
+  public static var max: ABC { return .c }
+  public static var min: ABC { return .a }
+}
+
+public enum Void: Int32, Enum {
+  public typealias T = Int32
+  public static var byteSize: Int { return MemoryLayout<Int32>.size }
+  public var value: Int32 { return self.rawValue }
+  case none_ = 0
+
+
+  public static var max: Void { return .none_ }
+  public static var min: Void { return .none_ }
+}
+
 public struct MoreDefaults: FlatBufferObject, ObjectAPIPacker {
 
   static func validateVersion() { FlatBuffersVersion_1_12_0() }
@@ -20,6 +44,9 @@ public struct MoreDefaults: FlatBufferObject, ObjectAPIPacker {
     case floats = 6
     case emptyString = 8
     case someString = 10
+    case abcs = 12
+    case voids = 14
+    case bools = 16
     var v: Int32 { Int32(self.rawValue) }
     var p: VOffset { self.rawValue }
   }
@@ -34,24 +61,40 @@ public struct MoreDefaults: FlatBufferObject, ObjectAPIPacker {
   public var emptyStringSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.emptyString.v) }
   public var someString: String? { let o = _accessor.offset(VTOFFSET.someString.v); return o == 0 ? "some" : _accessor.string(at: o) }
   public var someStringSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.someString.v) }
-  public static func startMoreDefaults(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 4) }
+  public var abcsCount: Int32 { let o = _accessor.offset(VTOFFSET.abcs.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+  public func abcs(at index: Int32) -> ABC? { let o = _accessor.offset(VTOFFSET.abcs.v); return o == 0 ? ABC.a : ABC(rawValue: _accessor.directRead(of: Int32.self, offset: _accessor.vector(at: o) + index * 4)) }
+  public var voidsCount: Int32 { let o = _accessor.offset(VTOFFSET.voids.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+  public func voids(at index: Int32) -> Void? { let o = _accessor.offset(VTOFFSET.voids.v); return o == 0 ? Void.none_ : Void(rawValue: _accessor.directRead(of: Int32.self, offset: _accessor.vector(at: o) + index * 4)) }
+  public var boolsCount: Int32 { let o = _accessor.offset(VTOFFSET.bools.v); return o == 0 ? 0 : _accessor.vector(count: o) }
+  public func bools(at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.bools.v); return o == 0 ? true : _accessor.directRead(of: Bool.self, offset: _accessor.vector(at: o) + index * 1) }
+  public var bools: [Bool] { return _accessor.getVector(at: VTOFFSET.bools.v) ?? [] }
+  public static func startMoreDefaults(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 7) }
   public static func addVectorOf(ints: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: ints, at: VTOFFSET.ints.p) }
   public static func addVectorOf(floats: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: floats, at: VTOFFSET.floats.p) }
   public static func add(emptyString: Offset<String>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: emptyString, at: VTOFFSET.emptyString.p) }
   public static func add(someString: Offset<String>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: someString, at: VTOFFSET.someString.p) }
+  public static func addVectorOf(abcs: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: abcs, at: VTOFFSET.abcs.p) }
+  public static func addVectorOf(voids: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: voids, at: VTOFFSET.voids.p) }
+  public static func addVectorOf(bools: Offset<UOffset>, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: bools, at: VTOFFSET.bools.p) }
   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,
     intsVectorOffset ints: Offset<UOffset> = Offset(),
     floatsVectorOffset floats: Offset<UOffset> = Offset(),
     emptyStringOffset emptyString: Offset<String> = Offset(),
-    someStringOffset someString: Offset<String> = Offset()
+    someStringOffset someString: Offset<String> = Offset(),
+    abcsVectorOffset abcs: Offset<UOffset> = Offset(),
+    voidsVectorOffset voids: Offset<UOffset> = Offset(),
+    boolsVectorOffset bools: Offset<UOffset> = Offset()
   ) -> Offset<UOffset> {
     let __start = MoreDefaults.startMoreDefaults(&fbb)
     MoreDefaults.addVectorOf(ints: ints, &fbb)
     MoreDefaults.addVectorOf(floats: floats, &fbb)
     MoreDefaults.add(emptyString: emptyString, &fbb)
     MoreDefaults.add(someString: someString, &fbb)
+    MoreDefaults.addVectorOf(abcs: abcs, &fbb)
+    MoreDefaults.addVectorOf(voids: voids, &fbb)
+    MoreDefaults.addVectorOf(bools: bools, &fbb)
     return MoreDefaults.endMoreDefaults(&fbb, start: __start)
   }
 
@@ -81,11 +124,17 @@ public struct MoreDefaults: FlatBufferObject, ObjectAPIPacker {
       __someString = Offset<String>()
     }
 
+    let __abcs = builder.createVector(obj.abcs)
+    let __voids = builder.createVector(obj.voids)
+    let __bools = builder.createVector(obj.bools)
     let __root = MoreDefaults.startMoreDefaults(&builder)
     MoreDefaults.addVectorOf(ints: __ints, &builder)
     MoreDefaults.addVectorOf(floats: __floats, &builder)
     MoreDefaults.add(emptyString: __emptyString, &builder)
     MoreDefaults.add(someString: __someString, &builder)
+    MoreDefaults.addVectorOf(abcs: __abcs, &builder)
+    MoreDefaults.addVectorOf(voids: __voids, &builder)
+    MoreDefaults.addVectorOf(bools: __bools, &builder)
     return MoreDefaults.endMoreDefaults(&builder, start: __root)
   }
 }
@@ -96,6 +145,9 @@ public class MoreDefaultsT: NativeObject {
   public var floats: [Float32]
   public var emptyString: String?
   public var someString: String?
+  public var abcs: [ABC]
+  public var voids: [Void]
+  public var bools: [Bool]
 
   public init(_ _t: inout MoreDefaults) {
     ints = []
@@ -108,13 +160,28 @@ public class MoreDefaultsT: NativeObject {
     }
     emptyString = _t.emptyString
     someString = _t.someString
+    abcs = []
+    for index in 0..<_t.abcsCount {
+        abcs.append(_t.abcs(at: index)!)
+    }
+    voids = []
+    for index in 0..<_t.voidsCount {
+        voids.append(_t.voids(at: index)!)
+    }
+    bools = []
+    for index in 0..<_t.boolsCount {
+        bools.append(_t.bools(at: index))
+    }
   }
 
   public init() {
     ints = []
     floats = []
     emptyString = ""
     someString = "some"
+    abcs = []
+    voids = []
+    bools = []
   }
 
   public func serialize() -> ByteBuffer { return serialize(type: MoreDefaults.self) }

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

@@ -4,7 +4,7 @@
 
 import FlatBuffers
 
-public enum optional_scalars_OptionalByte: Int8, Enum { 
+public enum optional_scalars_OptionalByte: Int8, Enum {
   public typealias T = Int8
   public static var byteSize: Int { return MemoryLayout<Int8>.size }
   public var value: Int8 { return self.rawValue }

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

@@ -4,7 +4,7 @@
 
 import FlatBuffers
 
-public enum Character: UInt8, Enum { 
+public enum Character: UInt8, Enum {
   public typealias T = UInt8
   public static var byteSize: Int { return MemoryLayout<UInt8>.size }
   public var value: UInt8 { return self.rawValue }

tests/more_defaults.fbs

@@ -1,7 +1,14 @@
 
+enum ABC: int { A, B, C }
+enum Void: int {}
+
+
 table MoreDefaults {
   ints: [int] = [];
   floats: [float] = [     ];
   empty_string: string = "";
   some_string: string = "some";
+  abcs: [ABC] = [];
+  voids: [Void] = [];
+  bools: [bool] = [];
 }