[swift] fix broken swift test build (#7633) (#7634)

* [swift] fix broken swift test build (#7633)

* [swift] fix unused variable (#7633)

* [swift] update generated code (#7633)

* [swift] add binary & json test for nan, inf, -inf for swift (#7633)

* [swift] use just '.infinity' instead of '+.infinity' (#7633)

* [swift] remove commented code (#7633)

Co-authored-by: Derek Bailey <derekbailey@google.com>
Co-authored-by: mustiikhalil <26250654+mustiikhalil@users.noreply.github.com>

scripts/generate_code.py

@@ -432,6 +432,7 @@ flatc(
 )
 flatc(SWIFT_OPTS, schema="optional_scalars.fbs", prefix=swift_prefix)
 flatc(SWIFT_OPTS, schema="vector_has_test.fbs", prefix=swift_prefix)
+flatc(SWIFT_OPTS, schema="nan_inf_test.fbs", prefix=swift_prefix)
 flatc(
     SWIFT_OPTS + ["--gen-object-api"],
     schema="more_defaults.fbs",

src/idl_gen_swift.cpp

@@ -258,11 +258,9 @@ class SwiftGenerator : public BaseGenerator {
           IsEnum(field.value.type) ? "{{BASEVALUE}}" : "{{VALUETYPE}}";
       code_ += "private var _{{FIELDVAR}}: " + valueType;
       const auto accessing_value = IsEnum(field.value.type) ? ".value" : "";
-      const auto is_bool = IsBool(field.value.type.base_type);
       const auto base_value =
           IsStruct(field.value.type) ? (type + "()")
-          : is_bool ? ("0" == field.value.constant ? "false" : "true")
+          : SwiftConstant(field);
-                    : field.value.constant;
 
       main_constructor.push_back("_" + field_var + " = " + field_var +
                                  accessing_value);
@@ -378,35 +376,6 @@ class SwiftGenerator : public BaseGenerator {
     code_ += "}\n";
   }
 
-  // Generates the create function for swift
-  void GenStructWriter(const StructDef &struct_def) {
-    const bool is_private_access =
-        parser_.opts.swift_implementation_only ||
-        struct_def.attributes.Lookup("private") != nullptr;
-    code_.SetValue("ACCESS_TYPE", is_private_access ? "internal" : "public");
-    code_.SetValue("STRUCTNAME", namer_.NamespacedType(struct_def));
-    code_.SetValue("SHORT_STRUCTNAME", namer_.Method(struct_def));
-    code_ += "extension {{STRUCTNAME}} {";
-    Indent();
-    code_ += "@discardableResult";
-    code_ +=
-        "{{ACCESS_TYPE}} static func create{{SHORT_STRUCTNAME}}(builder: inout "
-        "FlatBufferBuilder, \\";
-    std::string func_header = "";
-    GenerateStructArgs(struct_def, &func_header, "", "");
-    code_ += func_header.substr(0, func_header.size() - 2) + "\\";
-    code_ += ") -> Offset {";
-    Indent();
-    code_ +=
-        "builder.createStructOf(size: {{STRUCTNAME}}.size, alignment: "
-        "{{STRUCTNAME}}.alignment)";
-    code_ += "return builder.endStruct()";
-    Outdent();
-    code_ += "}\n";
-    Outdent();
-    code_ += "}\n";
-  }
-
   void GenerateStructArgs(const StructDef &struct_def, std::string *code_ptr,
                           const std::string &nameprefix,
                           const std::string &object_name,
@@ -430,11 +399,7 @@ class SwiftGenerator : public BaseGenerator {
           code += nameprefix + field_var + ": " + type;
           if (!IsEnum(field.value.type)) {
             code += " = ";
-            const auto is_bool = IsBool(field.value.type.base_type);
+            code += SwiftConstant(field);
-            const auto constant =
-                is_bool ? ("0" == field.value.constant ? "false" : "true")
-                        : field.value.constant;
-            code += constant;
           }
           code += ", ";
           continue;
@@ -633,7 +598,7 @@ class SwiftGenerator : public BaseGenerator {
     code_.SetValue("FIELDVAR", namer_.Variable(field));
     code_.SetValue("VALUETYPE", nullable_type);
     code_.SetValue("OFFSET", namer_.Field(field));
-    code_.SetValue("CONSTANT", field.value.constant);
+    code_.SetValue("CONSTANT", SwiftConstant(field));
     std::string check_if_vector =
         (IsVector(field.value.type) || IsArray(field.value.type)) ? "VectorOf("
                                                                   : "(";
@@ -659,7 +624,7 @@ class SwiftGenerator : public BaseGenerator {
       const auto default_value =
           IsEnum(field.value.type)
               ? (field.IsOptional() ? "nil" : GenEnumDefaultValue(field))
-              : field.value.constant;
+              : SwiftConstant(field);
       create_func_header.push_back(
           "" + field_field + ": " + nullable_type + " = " +
           (field.IsOptional() ? "nil" : default_value));
@@ -667,8 +632,7 @@ class SwiftGenerator : public BaseGenerator {
     }
 
     if (IsBool(field.value.type.base_type)) {
-      std::string default_value =
+      std::string default_value = SwiftConstant(field);
-          "0" == field.value.constant ? "false" : "true";
 
       code_.SetValue("CONSTANT", default_value);
       code_.SetValue("VALUETYPE", field.IsOptional() ? "Bool?" : "Bool");
@@ -743,7 +707,7 @@ class SwiftGenerator : public BaseGenerator {
     code_.SetValue("FIELDMETHOD", namer_.Method(field));
     code_.SetValue("VALUETYPE", type);
     code_.SetValue("OFFSET", namer_.Constant(field.name));
-    code_.SetValue("CONSTANT", field.value.constant);
+    code_.SetValue("CONSTANT", SwiftConstant(field));
     bool opt_scalar =
         field.IsOptional() && IsScalar(field.value.type.base_type);
     std::string def_Val = opt_scalar ? "nil" : "{{CONSTANT}}";
@@ -761,7 +725,7 @@ class SwiftGenerator : public BaseGenerator {
     if (IsBool(field.value.type.base_type)) {
       std::string default_value =
           field.IsOptional() ? "nil"
-                             : ("0" == field.value.constant ? "false" : "true");
+                             : SwiftConstant(field);
       code_.SetValue("CONSTANT", default_value);
       code_.SetValue("VALUETYPE", "Bool");
       code_ += GenReaderMainBody(optional) + "\\";
@@ -809,7 +773,7 @@ class SwiftGenerator : public BaseGenerator {
         break;
 
       case BASE_TYPE_STRING: {
-        const auto default_string = "\"" + field.value.constant + "\"";
+        const auto default_string = "\"" + SwiftConstant(field) + "\"";
         code_.SetValue("VALUETYPE", GenType(field.value.type));
         code_.SetValue("CONSTANT", field.IsDefault() ? default_string : "nil");
         code_ += GenReaderMainBody(is_required) + GenOffset() +
@@ -1017,20 +981,20 @@ class SwiftGenerator : public BaseGenerator {
           field.value.type.VectorType().base_type != BASE_TYPE_UTYPE;
 
       code_.SetValue("FIELDVAR", namer_.Variable(field));
-      code_.SetValue("CONSTANT", field.value.constant);
+      code_.SetValue("CONSTANT", SwiftConstant(field));
       bool should_indent = true;
       if (is_non_union_vector) {
         code_ += "if {{FIELDVAR}}Count > 0 {";
       } else if (IsEnum(type) && !field.IsOptional()) {
         code_.SetValue("CONSTANT", GenEnumDefaultValue(field));
         code_ += "if {{FIELDVAR}} != {{CONSTANT}} {";
+      } else if (IsFloat(type.base_type) && StringIsFlatbufferNan(field.value.constant)) {
+	code_ += "if !{{FIELDVAR}}.isNaN {";
       } else if (IsScalar(type.base_type) && !IsEnum(type) &&
                  !IsBool(type.base_type) && !field.IsOptional()) {
         code_ += "if {{FIELDVAR}} != {{CONSTANT}} {";
       } else if (IsBool(type.base_type) && !field.IsOptional()) {
-        std::string default_value =
+        code_.SetValue("CONSTANT", SwiftConstant(field));
-            "0" == field.value.constant ? "false" : "true";
-        code_.SetValue("CONSTANT", default_value);
         code_ += "if {{FIELDVAR}} != {{CONSTANT}} {";
       } else {
         should_indent = false;
@@ -1578,13 +1542,13 @@ class SwiftGenerator : public BaseGenerator {
 
         if (field.IsRequired()) {
           std::string default_value =
-              field.IsDefault() ? field.value.constant : "";
+              field.IsDefault() ? SwiftConstant(field) : "";
           base_constructor.push_back(field_var + " = \"" + default_value +
                                      "\"");
           break;
         }
         if (field.IsDefault() && !field.IsRequired()) {
-          std::string value = field.IsDefault() ? field.value.constant : "nil";
+          std::string value = field.IsDefault() ? SwiftConstant(field) : "nil";
           base_constructor.push_back(field_var + " = \"" + value + "\"");
         }
         break;
@@ -1603,14 +1567,14 @@ class SwiftGenerator : public BaseGenerator {
           code_ += "{{ACCESS_TYPE}} var {{FIELDVAR}}: {{VALUETYPE}}" + nullable;
           if (!field.IsOptional())
             base_constructor.push_back(field_var + " = " +
-                                       field.value.constant);
+                                       SwiftConstant(field));
           break;
         }
 
         if (IsEnum(field.value.type)) {
           const auto default_value = IsEnum(field.value.type)
                                          ? GenEnumDefaultValue(field)
-                                         : field.value.constant;
+                                         : SwiftConstant(field);
           code_ += "{{ACCESS_TYPE}} var {{FIELDVAR}}: {{VALUETYPE}}";
           base_constructor.push_back(field_var + " = " + default_value);
           break;
@@ -1618,10 +1582,8 @@ class SwiftGenerator : public BaseGenerator {
 
         if (IsBool(field.value.type.base_type)) {
           code_ += "{{ACCESS_TYPE}} var {{FIELDVAR}}: Bool" + nullable;
-          std::string default_value =
-              "0" == field.value.constant ? "false" : "true";
           if (!field.IsOptional())
-            base_constructor.push_back(field_var + " = " + default_value);
+            base_constructor.push_back(field_var + " = " + SwiftConstant(field));
         }
       }
     }
@@ -1676,7 +1638,7 @@ class SwiftGenerator : public BaseGenerator {
         if (IsEnum(vectortype) && vectortype.base_type != BASE_TYPE_UNION) {
           const auto default_value = IsEnum(field.value.type)
                                          ? GenEnumDefaultValue(field)
-                                         : field.value.constant;
+                                         : SwiftConstant(field);
           buffer_constructor.push_back(indentation + field_var + ".append(_t." +
                                        field_field + "(at: index)!)");
           break;
@@ -1869,6 +1831,16 @@ class SwiftGenerator : public BaseGenerator {
     }
   }
 
+  std::string SwiftConstant(const FieldDef& field) {
+    const auto default_value =
+        StringIsFlatbufferNan(field.value.constant) ? ".nan" :
+        StringIsFlatbufferPositiveInfinity(field.value.constant) ? ".infinity" :
+        StringIsFlatbufferNegativeInfinity(field.value.constant) ? "-.infinity" :
+        IsBool(field.value.type.base_type) ? ("0" == field.value.constant ? "false" : "true") :
+        field.value.constant;
+    return default_value;
+ }
+
   std::string GenEnumConstructor(const std::string &at) {
     return "{{VALUETYPE}}(rawValue: " + GenReader("BASEVALUE", at) + ") ";
   }

tests/nan_inf_test.fbs

@@ -0,0 +1,14 @@
+namespace Swift.Tests;
+
+table NanInfTable
+{
+  default_nan:double = nan;
+  default_inf:double = inf;
+  default_ninf:double = -inf;
+  value_nan:double;
+  value_inf:double;
+  value_ninf:double;
+  value:double;
+}
+
+root_type NanInfTable;

tests/swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests/monster_test_generated.swift

@@ -1184,6 +1184,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
     case nativeInline = 106
     case longEnumNonEnumDefault = 108
     case longEnumNormalDefault = 110
+    case nanDefault = 112
+    case infDefault = 114
+    case positiveInfDefault = 116
+    case infinityDefault = 118
+    case positiveInfinityDefault = 120
+    case negativeInfDefault = 122
+    case negativeInfinityDefault = 124
+    case doubleInfDefault = 126
     var v: Int32 { Int32(self.rawValue) }
     var p: VOffset { self.rawValue }
   }
@@ -1334,7 +1342,23 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
   @discardableResult public func mutate(longEnumNonEnumDefault: MyGame_Example_LongEnum) -> Bool {let o = _accessor.offset(VTOFFSET.longEnumNonEnumDefault.v);  return _accessor.mutate(longEnumNonEnumDefault.rawValue, index: o) }
   public var longEnumNormalDefault: MyGame_Example_LongEnum { let o = _accessor.offset(VTOFFSET.longEnumNormalDefault.v); return o == 0 ? .longone : MyGame_Example_LongEnum(rawValue: _accessor.readBuffer(of: UInt64.self, at: o)) ?? .longone }
   @discardableResult public func mutate(longEnumNormalDefault: MyGame_Example_LongEnum) -> Bool {let o = _accessor.offset(VTOFFSET.longEnumNormalDefault.v);  return _accessor.mutate(longEnumNormalDefault.rawValue, index: o) }
-  public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 54) }
+  public var nanDefault: Float32 { let o = _accessor.offset(VTOFFSET.nanDefault.v); return o == 0 ? .nan : _accessor.readBuffer(of: Float32.self, at: o) }
+  @discardableResult public func mutate(nanDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.nanDefault.v);  return _accessor.mutate(nanDefault, index: o) }
+  public var infDefault: Float32 { let o = _accessor.offset(VTOFFSET.infDefault.v); return o == 0 ? +.infinity : _accessor.readBuffer(of: Float32.self, at: o) }
+  @discardableResult public func mutate(infDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.infDefault.v);  return _accessor.mutate(infDefault, index: o) }
+  public var positiveInfDefault: Float32 { let o = _accessor.offset(VTOFFSET.positiveInfDefault.v); return o == 0 ? +.infinity : _accessor.readBuffer(of: Float32.self, at: o) }
+  @discardableResult public func mutate(positiveInfDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.positiveInfDefault.v);  return _accessor.mutate(positiveInfDefault, index: o) }
+  public var infinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.infinityDefault.v); return o == 0 ? +.infinity : _accessor.readBuffer(of: Float32.self, at: o) }
+  @discardableResult public func mutate(infinityDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.infinityDefault.v);  return _accessor.mutate(infinityDefault, index: o) }
+  public var positiveInfinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.positiveInfinityDefault.v); return o == 0 ? +.infinity : _accessor.readBuffer(of: Float32.self, at: o) }
+  @discardableResult public func mutate(positiveInfinityDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.positiveInfinityDefault.v);  return _accessor.mutate(positiveInfinityDefault, index: o) }
+  public var negativeInfDefault: Float32 { let o = _accessor.offset(VTOFFSET.negativeInfDefault.v); return o == 0 ? -.infinity : _accessor.readBuffer(of: Float32.self, at: o) }
+  @discardableResult public func mutate(negativeInfDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.negativeInfDefault.v);  return _accessor.mutate(negativeInfDefault, index: o) }
+  public var negativeInfinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.negativeInfinityDefault.v); return o == 0 ? -.infinity : _accessor.readBuffer(of: Float32.self, at: o) }
+  @discardableResult public func mutate(negativeInfinityDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.negativeInfinityDefault.v);  return _accessor.mutate(negativeInfinityDefault, index: o) }
+  public var doubleInfDefault: Double { let o = _accessor.offset(VTOFFSET.doubleInfDefault.v); return o == 0 ? +.infinity : _accessor.readBuffer(of: Double.self, at: o) }
+  @discardableResult public func mutate(doubleInfDefault: Double) -> Bool {let o = _accessor.offset(VTOFFSET.doubleInfDefault.v);  return _accessor.mutate(doubleInfDefault, index: o) }
+  public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 62) }
   public static func add(pos: MyGame_Example_Vec3?, _ fbb: inout FlatBufferBuilder) { guard let pos = pos else { return }; fbb.create(struct: pos, position: VTOFFSET.pos.p) }
   public static func add(mana: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: mana, def: 150, at: VTOFFSET.mana.p) }
   public static func add(hp: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: hp, def: 100, at: VTOFFSET.hp.p) }
@@ -1398,6 +1422,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
   public static func add(nativeInline: MyGame_Example_Test?, _ fbb: inout FlatBufferBuilder) { guard let nativeInline = nativeInline else { return }; fbb.create(struct: nativeInline, position: VTOFFSET.nativeInline.p) }
   public static func add(longEnumNonEnumDefault: MyGame_Example_LongEnum, _ fbb: inout FlatBufferBuilder) { fbb.add(element: longEnumNonEnumDefault.rawValue, def: 0, at: VTOFFSET.longEnumNonEnumDefault.p) }
   public static func add(longEnumNormalDefault: MyGame_Example_LongEnum, _ fbb: inout FlatBufferBuilder) { fbb.add(element: longEnumNormalDefault.rawValue, def: 2, at: VTOFFSET.longEnumNormalDefault.p) }
+  public static func add(nanDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: nanDefault, def: .nan, at: VTOFFSET.nanDefault.p) }
+  public static func add(infDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: infDefault, def: +.infinity, at: VTOFFSET.infDefault.p) }
+  public static func add(positiveInfDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: positiveInfDefault, def: +.infinity, at: VTOFFSET.positiveInfDefault.p) }
+  public static func add(infinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: infinityDefault, def: +.infinity, at: VTOFFSET.infinityDefault.p) }
+  public static func add(positiveInfinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: positiveInfinityDefault, def: +.infinity, at: VTOFFSET.positiveInfinityDefault.p) }
+  public static func add(negativeInfDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: negativeInfDefault, def: -.infinity, at: VTOFFSET.negativeInfDefault.p) }
+  public static func add(negativeInfinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: negativeInfinityDefault, def: -.infinity, at: VTOFFSET.negativeInfinityDefault.p) }
+  public static func add(doubleInfDefault: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: doubleInfDefault, def: +.infinity, at: VTOFFSET.doubleInfDefault.p) }
   public static func endMonster(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); fbb.require(table: end, fields: [10]); return end }
   public static func createMonster(
     _ fbb: inout FlatBufferBuilder,
@@ -1453,7 +1485,15 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
     scalarKeySortedTablesVectorOffset scalarKeySortedTables: Offset = Offset(),
     nativeInline: MyGame_Example_Test? = nil,
     longEnumNonEnumDefault: MyGame_Example_LongEnum = .longone,
-    longEnumNormalDefault: MyGame_Example_LongEnum = .longone
+    longEnumNormalDefault: MyGame_Example_LongEnum = .longone,
+    nanDefault: Float32 = .nan,
+    infDefault: Float32 = +.infinity,
+    positiveInfDefault: Float32 = +.infinity,
+    infinityDefault: Float32 = +.infinity,
+    positiveInfinityDefault: Float32 = +.infinity,
+    negativeInfDefault: Float32 = -.infinity,
+    negativeInfinityDefault: Float32 = -.infinity,
+    doubleInfDefault: Double = +.infinity
   ) -> Offset {
     let __start = MyGame_Example_Monster.startMonster(&fbb)
     MyGame_Example_Monster.add(pos: pos, &fbb)
@@ -1509,6 +1549,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
     MyGame_Example_Monster.add(nativeInline: nativeInline, &fbb)
     MyGame_Example_Monster.add(longEnumNonEnumDefault: longEnumNonEnumDefault, &fbb)
     MyGame_Example_Monster.add(longEnumNormalDefault: longEnumNormalDefault, &fbb)
+    MyGame_Example_Monster.add(nanDefault: nanDefault, &fbb)
+    MyGame_Example_Monster.add(infDefault: infDefault, &fbb)
+    MyGame_Example_Monster.add(positiveInfDefault: positiveInfDefault, &fbb)
+    MyGame_Example_Monster.add(infinityDefault: infinityDefault, &fbb)
+    MyGame_Example_Monster.add(positiveInfinityDefault: positiveInfinityDefault, &fbb)
+    MyGame_Example_Monster.add(negativeInfDefault: negativeInfDefault, &fbb)
+    MyGame_Example_Monster.add(negativeInfinityDefault: negativeInfinityDefault, &fbb)
+    MyGame_Example_Monster.add(doubleInfDefault: doubleInfDefault, &fbb)
     return MyGame_Example_Monster.endMonster(&fbb, start: __start)
   }
   public static func sortVectorOfMonster(offsets:[Offset], _ fbb: inout FlatBufferBuilder) -> Offset {
@@ -1668,6 +1716,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
     MyGame_Example_Monster.add(nativeInline: obj.nativeInline, &builder)
     MyGame_Example_Monster.add(longEnumNonEnumDefault: obj.longEnumNonEnumDefault, &builder)
     MyGame_Example_Monster.add(longEnumNormalDefault: obj.longEnumNormalDefault, &builder)
+    MyGame_Example_Monster.add(nanDefault: obj.nanDefault, &builder)
+    MyGame_Example_Monster.add(infDefault: obj.infDefault, &builder)
+    MyGame_Example_Monster.add(positiveInfDefault: obj.positiveInfDefault, &builder)
+    MyGame_Example_Monster.add(infinityDefault: obj.infinityDefault, &builder)
+    MyGame_Example_Monster.add(positiveInfinityDefault: obj.positiveInfinityDefault, &builder)
+    MyGame_Example_Monster.add(negativeInfDefault: obj.negativeInfDefault, &builder)
+    MyGame_Example_Monster.add(negativeInfinityDefault: obj.negativeInfinityDefault, &builder)
+    MyGame_Example_Monster.add(doubleInfDefault: obj.doubleInfDefault, &builder)
     return MyGame_Example_Monster.endMonster(&builder, start: __root)
   }
 
@@ -1756,6 +1812,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
     try _v.visit(field: VTOFFSET.nativeInline.p, fieldName: "nativeInline", required: false, type: MyGame_Example_Test.self)
     try _v.visit(field: VTOFFSET.longEnumNonEnumDefault.p, fieldName: "longEnumNonEnumDefault", required: false, type: MyGame_Example_LongEnum.self)
     try _v.visit(field: VTOFFSET.longEnumNormalDefault.p, fieldName: "longEnumNormalDefault", required: false, type: MyGame_Example_LongEnum.self)
+    try _v.visit(field: VTOFFSET.nanDefault.p, fieldName: "nanDefault", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.infDefault.p, fieldName: "infDefault", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.positiveInfDefault.p, fieldName: "positiveInfDefault", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.infinityDefault.p, fieldName: "infinityDefault", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.positiveInfinityDefault.p, fieldName: "positiveInfinityDefault", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.negativeInfDefault.p, fieldName: "negativeInfDefault", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.negativeInfinityDefault.p, fieldName: "negativeInfinityDefault", required: false, type: Float32.self)
+    try _v.visit(field: VTOFFSET.doubleInfDefault.p, fieldName: "doubleInfDefault", required: false, type: Double.self)
     _v.finish()
   }
 }
@@ -1816,6 +1880,14 @@ extension MyGame_Example_Monster: Encodable {
     case nativeInline = "native_inline"
     case longEnumNonEnumDefault = "long_enum_non_enum_default"
     case longEnumNormalDefault = "long_enum_normal_default"
+    case nanDefault = "nan_default"
+    case infDefault = "inf_default"
+    case positiveInfDefault = "positive_inf_default"
+    case infinityDefault = "infinity_default"
+    case positiveInfinityDefault = "positive_infinity_default"
+    case negativeInfDefault = "negative_inf_default"
+    case negativeInfinityDefault = "negative_infinity_default"
+    case doubleInfDefault = "double_inf_default"
   }
   public func encode(to encoder: Encoder) throws {
     var container = encoder.container(keyedBy: CodingKeys.self)
@@ -2033,6 +2105,30 @@ extension MyGame_Example_Monster: Encodable {
     if longEnumNormalDefault != .longone {
       try container.encodeIfPresent(longEnumNormalDefault, forKey: .longEnumNormalDefault)
     }
+    if !nanDefault.isNaN {
+      try container.encodeIfPresent(nanDefault, forKey: .nanDefault)
+    }
+    if infDefault != +.infinity {
+      try container.encodeIfPresent(infDefault, forKey: .infDefault)
+    }
+    if positiveInfDefault != +.infinity {
+      try container.encodeIfPresent(positiveInfDefault, forKey: .positiveInfDefault)
+    }
+    if infinityDefault != +.infinity {
+      try container.encodeIfPresent(infinityDefault, forKey: .infinityDefault)
+    }
+    if positiveInfinityDefault != +.infinity {
+      try container.encodeIfPresent(positiveInfinityDefault, forKey: .positiveInfinityDefault)
+    }
+    if negativeInfDefault != -.infinity {
+      try container.encodeIfPresent(negativeInfDefault, forKey: .negativeInfDefault)
+    }
+    if negativeInfinityDefault != -.infinity {
+      try container.encodeIfPresent(negativeInfinityDefault, forKey: .negativeInfinityDefault)
+    }
+    if doubleInfDefault != +.infinity {
+      try container.encodeIfPresent(doubleInfDefault, forKey: .doubleInfDefault)
+    }
   }
 }
 
@@ -2088,6 +2184,14 @@ public class MyGame_Example_MonsterT: NativeObject {
   public var nativeInline: MyGame_Example_Test?
   public var longEnumNonEnumDefault: MyGame_Example_LongEnum
   public var longEnumNormalDefault: MyGame_Example_LongEnum
+  public var nanDefault: Float32
+  public var infDefault: Float32
+  public var positiveInfDefault: Float32
+  public var infinityDefault: Float32
+  public var positiveInfinityDefault: Float32
+  public var negativeInfDefault: Float32
+  public var negativeInfinityDefault: Float32
+  public var doubleInfDefault: Double
 
   public init(_ _t: inout MyGame_Example_Monster) {
     pos = _t.pos
@@ -2240,6 +2344,14 @@ public class MyGame_Example_MonsterT: NativeObject {
     nativeInline = _t.nativeInline
     longEnumNonEnumDefault = _t.longEnumNonEnumDefault
     longEnumNormalDefault = _t.longEnumNormalDefault
+    nanDefault = _t.nanDefault
+    infDefault = _t.infDefault
+    positiveInfDefault = _t.positiveInfDefault
+    infinityDefault = _t.infinityDefault
+    positiveInfinityDefault = _t.positiveInfinityDefault
+    negativeInfDefault = _t.negativeInfDefault
+    negativeInfinityDefault = _t.negativeInfinityDefault
+    doubleInfDefault = _t.doubleInfDefault
   }
 
   public init() {
@@ -2290,6 +2402,14 @@ public class MyGame_Example_MonsterT: NativeObject {
     nativeInline = MyGame_Example_Test()
     longEnumNonEnumDefault = .longone
     longEnumNormalDefault = .longone
+    nanDefault = .nan
+    infDefault = +.infinity
+    positiveInfDefault = +.infinity
+    infinityDefault = +.infinity
+    positiveInfinityDefault = +.infinity
+    negativeInfDefault = -.infinity
+    negativeInfinityDefault = -.infinity
+    doubleInfDefault = +.infinity
   }
 
   public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Monster.self) }

tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersNanInfTests.swift

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2022 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import XCTest
+@testable import FlatBuffers
+
+final class FlatBuffersNanInfTests: XCTestCase {
+
+    func createTestTable() -> FlatBufferBuilder {
+        var fbb = FlatBufferBuilder()
+        let msg = Swift_Tests_NanInfTable.createNanInfTable(&fbb,
+            valueNan: .nan,
+            valueInf: .infinity,
+            valueNinf: -.infinity,
+            value: 100.0
+        )
+        fbb.finish(offset: msg)
+        return fbb
+    }
+
+    func testInfNanBinary() {
+        let fbb = createTestTable()
+        let data = fbb.sizedByteArray
+        
+        let table = Swift_Tests_NanInfTable.getRootAsNanInfTable(bb: ByteBuffer(bytes: data))
+        XCTAssert(table.defaultNan.isNaN)
+        XCTAssertEqual(table.defaultInf, .infinity)
+        XCTAssertEqual(table.defaultNinf, -.infinity)
+        XCTAssert(table.valueNan.isNaN)
+        XCTAssertEqual(table.valueInf, .infinity)
+        XCTAssertEqual(table.valueNinf, -.infinity)
+        XCTAssertEqual(table.value, 100.0)
+    }
+    
+    func testInfNanJSON() {
+        let fbb = createTestTable()
+        var bb = fbb.sizedBuffer
+        do {
+            let reader: Swift_Tests_NanInfTable = try getCheckedRoot(byteBuffer: &bb)
+            let encoder = JSONEncoder()
+            encoder.keyEncodingStrategy = .convertToSnakeCase
+            encoder.nonConformingFloatEncodingStrategy =
+                .convertToString(positiveInfinity: "inf", negativeInfinity: "-inf", nan: "nan")
+            let data = try encoder.encode(reader)
+            XCTAssertEqual(data, jsonData.data(using: .utf8))
+        } catch {
+            XCTFail(error.localizedDescription)
+        }
+    }
+    
+    var jsonData: String {
+        "{\"value_inf\":\"inf\",\"value\":100,\"value_nan\":\"nan\",\"value_ninf\":\"-inf\"}"
+    }
+    
+}

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

@@ -1342,21 +1342,21 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
   @discardableResult public func mutate(longEnumNonEnumDefault: MyGame_Example_LongEnum) -> Bool {let o = _accessor.offset(VTOFFSET.longEnumNonEnumDefault.v);  return _accessor.mutate(longEnumNonEnumDefault.rawValue, index: o) }
   public var longEnumNormalDefault: MyGame_Example_LongEnum { let o = _accessor.offset(VTOFFSET.longEnumNormalDefault.v); return o == 0 ? .longone : MyGame_Example_LongEnum(rawValue: _accessor.readBuffer(of: UInt64.self, at: o)) ?? .longone }
   @discardableResult public func mutate(longEnumNormalDefault: MyGame_Example_LongEnum) -> Bool {let o = _accessor.offset(VTOFFSET.longEnumNormalDefault.v);  return _accessor.mutate(longEnumNormalDefault.rawValue, index: o) }
-  public var nanDefault: Float32 { let o = _accessor.offset(VTOFFSET.nanDefault.v); return o == 0 ? nan : _accessor.readBuffer(of: Float32.self, at: o) }
+  public var nanDefault: Float32 { let o = _accessor.offset(VTOFFSET.nanDefault.v); return o == 0 ? .nan : _accessor.readBuffer(of: Float32.self, at: o) }
   @discardableResult public func mutate(nanDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.nanDefault.v);  return _accessor.mutate(nanDefault, index: o) }
-  public var infDefault: Float32 { let o = _accessor.offset(VTOFFSET.infDefault.v); return o == 0 ? inf : _accessor.readBuffer(of: Float32.self, at: o) }
+  public var infDefault: Float32 { let o = _accessor.offset(VTOFFSET.infDefault.v); return o == 0 ? .infinity : _accessor.readBuffer(of: Float32.self, at: o) }
   @discardableResult public func mutate(infDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.infDefault.v);  return _accessor.mutate(infDefault, index: o) }
-  public var positiveInfDefault: Float32 { let o = _accessor.offset(VTOFFSET.positiveInfDefault.v); return o == 0 ? +inf : _accessor.readBuffer(of: Float32.self, at: o) }
+  public var positiveInfDefault: Float32 { let o = _accessor.offset(VTOFFSET.positiveInfDefault.v); return o == 0 ? .infinity : _accessor.readBuffer(of: Float32.self, at: o) }
   @discardableResult public func mutate(positiveInfDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.positiveInfDefault.v);  return _accessor.mutate(positiveInfDefault, index: o) }
-  public var infinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.infinityDefault.v); return o == 0 ? infinity : _accessor.readBuffer(of: Float32.self, at: o) }
+  public var infinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.infinityDefault.v); return o == 0 ? .infinity : _accessor.readBuffer(of: Float32.self, at: o) }
   @discardableResult public func mutate(infinityDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.infinityDefault.v);  return _accessor.mutate(infinityDefault, index: o) }
-  public var positiveInfinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.positiveInfinityDefault.v); return o == 0 ? +infinity : _accessor.readBuffer(of: Float32.self, at: o) }
+  public var positiveInfinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.positiveInfinityDefault.v); return o == 0 ? .infinity : _accessor.readBuffer(of: Float32.self, at: o) }
   @discardableResult public func mutate(positiveInfinityDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.positiveInfinityDefault.v);  return _accessor.mutate(positiveInfinityDefault, index: o) }
-  public var negativeInfDefault: Float32 { let o = _accessor.offset(VTOFFSET.negativeInfDefault.v); return o == 0 ? -inf : _accessor.readBuffer(of: Float32.self, at: o) }
+  public var negativeInfDefault: Float32 { let o = _accessor.offset(VTOFFSET.negativeInfDefault.v); return o == 0 ? -.infinity : _accessor.readBuffer(of: Float32.self, at: o) }
   @discardableResult public func mutate(negativeInfDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.negativeInfDefault.v);  return _accessor.mutate(negativeInfDefault, index: o) }
-  public var negativeInfinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.negativeInfinityDefault.v); return o == 0 ? -infinity : _accessor.readBuffer(of: Float32.self, at: o) }
+  public var negativeInfinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.negativeInfinityDefault.v); return o == 0 ? -.infinity : _accessor.readBuffer(of: Float32.self, at: o) }
   @discardableResult public func mutate(negativeInfinityDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.negativeInfinityDefault.v);  return _accessor.mutate(negativeInfinityDefault, index: o) }
-  public var doubleInfDefault: Double { let o = _accessor.offset(VTOFFSET.doubleInfDefault.v); return o == 0 ? inf : _accessor.readBuffer(of: Double.self, at: o) }
+  public var doubleInfDefault: Double { let o = _accessor.offset(VTOFFSET.doubleInfDefault.v); return o == 0 ? .infinity : _accessor.readBuffer(of: Double.self, at: o) }
   @discardableResult public func mutate(doubleInfDefault: Double) -> Bool {let o = _accessor.offset(VTOFFSET.doubleInfDefault.v);  return _accessor.mutate(doubleInfDefault, index: o) }
   public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 62) }
   public static func add(pos: MyGame_Example_Vec3?, _ fbb: inout FlatBufferBuilder) { guard let pos = pos else { return }; fbb.create(struct: pos, position: VTOFFSET.pos.p) }
@@ -1422,14 +1422,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
   public static func add(nativeInline: MyGame_Example_Test?, _ fbb: inout FlatBufferBuilder) { guard let nativeInline = nativeInline else { return }; fbb.create(struct: nativeInline, position: VTOFFSET.nativeInline.p) }
   public static func add(longEnumNonEnumDefault: MyGame_Example_LongEnum, _ fbb: inout FlatBufferBuilder) { fbb.add(element: longEnumNonEnumDefault.rawValue, def: 0, at: VTOFFSET.longEnumNonEnumDefault.p) }
   public static func add(longEnumNormalDefault: MyGame_Example_LongEnum, _ fbb: inout FlatBufferBuilder) { fbb.add(element: longEnumNormalDefault.rawValue, def: 2, at: VTOFFSET.longEnumNormalDefault.p) }
-  public static func add(nanDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: nanDefault, def: nan, at: VTOFFSET.nanDefault.p) }
+  public static func add(nanDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: nanDefault, def: .nan, at: VTOFFSET.nanDefault.p) }
-  public static func add(infDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: infDefault, def: inf, at: VTOFFSET.infDefault.p) }
+  public static func add(infDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: infDefault, def: .infinity, at: VTOFFSET.infDefault.p) }
-  public static func add(positiveInfDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: positiveInfDefault, def: +inf, at: VTOFFSET.positiveInfDefault.p) }
+  public static func add(positiveInfDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: positiveInfDefault, def: .infinity, at: VTOFFSET.positiveInfDefault.p) }
-  public static func add(infinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: infinityDefault, def: infinity, at: VTOFFSET.infinityDefault.p) }
+  public static func add(infinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: infinityDefault, def: .infinity, at: VTOFFSET.infinityDefault.p) }
-  public static func add(positiveInfinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: positiveInfinityDefault, def: +infinity, at: VTOFFSET.positiveInfinityDefault.p) }
+  public static func add(positiveInfinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: positiveInfinityDefault, def: .infinity, at: VTOFFSET.positiveInfinityDefault.p) }
-  public static func add(negativeInfDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: negativeInfDefault, def: -inf, at: VTOFFSET.negativeInfDefault.p) }
+  public static func add(negativeInfDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: negativeInfDefault, def: -.infinity, at: VTOFFSET.negativeInfDefault.p) }
-  public static func add(negativeInfinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: negativeInfinityDefault, def: -infinity, at: VTOFFSET.negativeInfinityDefault.p) }
+  public static func add(negativeInfinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: negativeInfinityDefault, def: -.infinity, at: VTOFFSET.negativeInfinityDefault.p) }
-  public static func add(doubleInfDefault: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: doubleInfDefault, def: inf, at: VTOFFSET.doubleInfDefault.p) }
+  public static func add(doubleInfDefault: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: doubleInfDefault, def: .infinity, at: VTOFFSET.doubleInfDefault.p) }
   public static func endMonster(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); fbb.require(table: end, fields: [10]); return end }
   public static func createMonster(
     _ fbb: inout FlatBufferBuilder,
@@ -1486,14 +1486,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac
     nativeInline: MyGame_Example_Test? = nil,
     longEnumNonEnumDefault: MyGame_Example_LongEnum = .longone,
     longEnumNormalDefault: MyGame_Example_LongEnum = .longone,
-    nanDefault: Float32 = nan,
+    nanDefault: Float32 = .nan,
-    infDefault: Float32 = inf,
+    infDefault: Float32 = .infinity,
-    positiveInfDefault: Float32 = +inf,
+    positiveInfDefault: Float32 = .infinity,
-    infinityDefault: Float32 = infinity,
+    infinityDefault: Float32 = .infinity,
-    positiveInfinityDefault: Float32 = +infinity,
+    positiveInfinityDefault: Float32 = .infinity,
-    negativeInfDefault: Float32 = -inf,
+    negativeInfDefault: Float32 = -.infinity,
-    negativeInfinityDefault: Float32 = -infinity,
+    negativeInfinityDefault: Float32 = -.infinity,
-    doubleInfDefault: Double = inf
+    doubleInfDefault: Double = .infinity
   ) -> Offset {
     let __start = MyGame_Example_Monster.startMonster(&fbb)
     MyGame_Example_Monster.add(pos: pos, &fbb)
@@ -2105,28 +2105,28 @@ extension MyGame_Example_Monster: Encodable {
     if longEnumNormalDefault != .longone {
       try container.encodeIfPresent(longEnumNormalDefault, forKey: .longEnumNormalDefault)
     }
-    if nanDefault != nan {
+    if !nanDefault.isNaN {
       try container.encodeIfPresent(nanDefault, forKey: .nanDefault)
     }
-    if infDefault != inf {
+    if infDefault != .infinity {
       try container.encodeIfPresent(infDefault, forKey: .infDefault)
     }
-    if positiveInfDefault != +inf {
+    if positiveInfDefault != .infinity {
       try container.encodeIfPresent(positiveInfDefault, forKey: .positiveInfDefault)
     }
-    if infinityDefault != infinity {
+    if infinityDefault != .infinity {
       try container.encodeIfPresent(infinityDefault, forKey: .infinityDefault)
     }
-    if positiveInfinityDefault != +infinity {
+    if positiveInfinityDefault != .infinity {
       try container.encodeIfPresent(positiveInfinityDefault, forKey: .positiveInfinityDefault)
     }
-    if negativeInfDefault != -inf {
+    if negativeInfDefault != -.infinity {
       try container.encodeIfPresent(negativeInfDefault, forKey: .negativeInfDefault)
     }
-    if negativeInfinityDefault != -infinity {
+    if negativeInfinityDefault != -.infinity {
       try container.encodeIfPresent(negativeInfinityDefault, forKey: .negativeInfinityDefault)
     }
-    if doubleInfDefault != inf {
+    if doubleInfDefault != .infinity {
       try container.encodeIfPresent(doubleInfDefault, forKey: .doubleInfDefault)
     }
   }
@@ -2402,14 +2402,14 @@ public class MyGame_Example_MonsterT: NativeObject {
     nativeInline = MyGame_Example_Test()
     longEnumNonEnumDefault = .longone
     longEnumNormalDefault = .longone
-    nanDefault = nan
+    nanDefault = .nan
-    infDefault = inf
+    infDefault = .infinity
-    positiveInfDefault = +inf
+    positiveInfDefault = .infinity
-    infinityDefault = infinity
+    infinityDefault = .infinity
-    positiveInfinityDefault = +infinity
+    positiveInfinityDefault = .infinity
-    negativeInfDefault = -inf
+    negativeInfDefault = -.infinity
-    negativeInfinityDefault = -infinity
+    negativeInfinityDefault = -.infinity
-    doubleInfDefault = inf
+    doubleInfDefault = .infinity
   }
 
   public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Monster.self) }

tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/nan_inf_test_generated.swift

@@ -0,0 +1,116 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// swiftlint:disable all
+// swiftformat:disable all
+
+import FlatBuffers
+
+public struct Swift_Tests_NanInfTable: FlatBufferObject, Verifiable {
+
+  static func validateVersion() { FlatBuffersVersion_22_10_26() }
+  public var __buffer: ByteBuffer! { return _accessor.bb }
+  private var _accessor: Table
+
+  public static func getRootAsNanInfTable(bb: ByteBuffer) -> Swift_Tests_NanInfTable { return Swift_Tests_NanInfTable(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) }
+
+  private enum VTOFFSET: VOffset {
+    case defaultNan = 4
+    case defaultInf = 6
+    case defaultNinf = 8
+    case valueNan = 10
+    case valueInf = 12
+    case valueNinf = 14
+    case value = 16
+    var v: Int32 { Int32(self.rawValue) }
+    var p: VOffset { self.rawValue }
+  }
+
+  public var defaultNan: Double { let o = _accessor.offset(VTOFFSET.defaultNan.v); return o == 0 ? .nan : _accessor.readBuffer(of: Double.self, at: o) }
+  public var defaultInf: Double { let o = _accessor.offset(VTOFFSET.defaultInf.v); return o == 0 ? .infinity : _accessor.readBuffer(of: Double.self, at: o) }
+  public var defaultNinf: Double { let o = _accessor.offset(VTOFFSET.defaultNinf.v); return o == 0 ? -.infinity : _accessor.readBuffer(of: Double.self, at: o) }
+  public var valueNan: Double { let o = _accessor.offset(VTOFFSET.valueNan.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
+  public var valueInf: Double { let o = _accessor.offset(VTOFFSET.valueInf.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
+  public var valueNinf: Double { let o = _accessor.offset(VTOFFSET.valueNinf.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
+  public var value: Double { let o = _accessor.offset(VTOFFSET.value.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) }
+  public static func startNanInfTable(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 7) }
+  public static func add(defaultNan: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultNan, def: .nan, at: VTOFFSET.defaultNan.p) }
+  public static func add(defaultInf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultInf, def: .infinity, at: VTOFFSET.defaultInf.p) }
+  public static func add(defaultNinf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultNinf, def: -.infinity, at: VTOFFSET.defaultNinf.p) }
+  public static func add(valueNan: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: valueNan, def: 0.0, at: VTOFFSET.valueNan.p) }
+  public static func add(valueInf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: valueInf, def: 0.0, at: VTOFFSET.valueInf.p) }
+  public static func add(valueNinf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: valueNinf, def: 0.0, at: VTOFFSET.valueNinf.p) }
+  public static func add(value: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: value, def: 0.0, at: VTOFFSET.value.p) }
+  public static func endNanInfTable(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
+  public static func createNanInfTable(
+    _ fbb: inout FlatBufferBuilder,
+    defaultNan: Double = .nan,
+    defaultInf: Double = .infinity,
+    defaultNinf: Double = -.infinity,
+    valueNan: Double = 0.0,
+    valueInf: Double = 0.0,
+    valueNinf: Double = 0.0,
+    value: Double = 0.0
+  ) -> Offset {
+    let __start = Swift_Tests_NanInfTable.startNanInfTable(&fbb)
+    Swift_Tests_NanInfTable.add(defaultNan: defaultNan, &fbb)
+    Swift_Tests_NanInfTable.add(defaultInf: defaultInf, &fbb)
+    Swift_Tests_NanInfTable.add(defaultNinf: defaultNinf, &fbb)
+    Swift_Tests_NanInfTable.add(valueNan: valueNan, &fbb)
+    Swift_Tests_NanInfTable.add(valueInf: valueInf, &fbb)
+    Swift_Tests_NanInfTable.add(valueNinf: valueNinf, &fbb)
+    Swift_Tests_NanInfTable.add(value: value, &fbb)
+    return Swift_Tests_NanInfTable.endNanInfTable(&fbb, start: __start)
+  }
+
+  public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
+    var _v = try verifier.visitTable(at: position)
+    try _v.visit(field: VTOFFSET.defaultNan.p, fieldName: "defaultNan", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.defaultInf.p, fieldName: "defaultInf", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.defaultNinf.p, fieldName: "defaultNinf", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.valueNan.p, fieldName: "valueNan", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.valueInf.p, fieldName: "valueInf", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.valueNinf.p, fieldName: "valueNinf", required: false, type: Double.self)
+    try _v.visit(field: VTOFFSET.value.p, fieldName: "value", required: false, type: Double.self)
+    _v.finish()
+  }
+}
+
+extension Swift_Tests_NanInfTable: Encodable {
+
+  enum CodingKeys: String, CodingKey {
+    case defaultNan = "default_nan"
+    case defaultInf = "default_inf"
+    case defaultNinf = "default_ninf"
+    case valueNan = "value_nan"
+    case valueInf = "value_inf"
+    case valueNinf = "value_ninf"
+    case value = "value"
+  }
+  public func encode(to encoder: Encoder) throws {
+    var container = encoder.container(keyedBy: CodingKeys.self)
+    if !defaultNan.isNaN {
+      try container.encodeIfPresent(defaultNan, forKey: .defaultNan)
+    }
+    if defaultInf != .infinity {
+      try container.encodeIfPresent(defaultInf, forKey: .defaultInf)
+    }
+    if defaultNinf != -.infinity {
+      try container.encodeIfPresent(defaultNinf, forKey: .defaultNinf)
+    }
+    if valueNan != 0.0 {
+      try container.encodeIfPresent(valueNan, forKey: .valueNan)
+    }
+    if valueInf != 0.0 {
+      try container.encodeIfPresent(valueInf, forKey: .valueInf)
+    }
+    if valueNinf != 0.0 {
+      try container.encodeIfPresent(valueNinf, forKey: .valueNinf)
+    }
+    if value != 0.0 {
+      try container.encodeIfPresent(value, forKey: .value)
+    }
+  }
+}
+