Fix handling of +/-inf defaults in TS/rust/go/dart codegen (#7588)

+/-inf were not being handled, and so invalid typescript was being
generated when a float/double had an infinite default value. NaN was
being handled correctly.

Co-authored-by: Derek Bailey <derekbailey@google.com>
Co-authored-by: Casper <casperneo@uchicago.edu>

dart/test/flat_buffers_test.dart

@@ -87,7 +87,10 @@ class CheckOtherLangaugesData {
       'testrequirednestedflatbuffer: null, scalarKeySortedTables: null, '
       'nativeInline: null, '
       'longEnumNonEnumDefault: LongEnum{value: 0}, '
-      'longEnumNormalDefault: LongEnum{value: 2}}, '
+      'longEnumNormalDefault: LongEnum{value: 2}, nanDefault: NaN, '
+      'infDefault: Infinity, positiveInfDefault: Infinity, infinityDefault: '
+      'Infinity, positiveInfinityDefault: Infinity, negativeInfDefault: '
+      '-Infinity, negativeInfinityDefault: -Infinity, doubleInfDefault: Infinity}, '
       'test4: [Test{a: 10, b: 20}, Test{a: 30, b: 40}], '
       'testarrayofstring: [test1, test2], testarrayoftables: null, '
       'enemy: Monster{pos: null, mana: 150, hp: 100, name: Fred, '
@@ -110,7 +113,10 @@ class CheckOtherLangaugesData {
       'testrequirednestedflatbuffer: null, scalarKeySortedTables: null, '
       'nativeInline: null, '
       'longEnumNonEnumDefault: LongEnum{value: 0}, '
-      'longEnumNormalDefault: LongEnum{value: 2}}, '
+      'longEnumNormalDefault: LongEnum{value: 2}, nanDefault: NaN, '
+      'infDefault: Infinity, positiveInfDefault: Infinity, infinityDefault: '
+      'Infinity, positiveInfinityDefault: Infinity, negativeInfDefault: '
+      '-Infinity, negativeInfinityDefault: -Infinity, doubleInfDefault: Infinity}, '
       'testnestedflatbuffer: null, testempty: null, testbool: true, '
       'testhashs32Fnv1: -579221183, testhashu32Fnv1: 3715746113, '
       'testhashs64Fnv1: 7930699090847568257, '
@@ -137,7 +143,10 @@ class CheckOtherLangaugesData {
       'miss, val: 0, count: 0}, Stat{id: hit, val: 10, count: 1}], '
       'nativeInline: Test{a: 1, b: 2}, '
       'longEnumNonEnumDefault: LongEnum{value: 0}, '
-      'longEnumNormalDefault: LongEnum{value: 2}}',
+      'longEnumNormalDefault: LongEnum{value: 2}, nanDefault: NaN, '
+      'infDefault: Infinity, positiveInfDefault: Infinity, infinityDefault: '
+      'Infinity, positiveInfinityDefault: Infinity, negativeInfDefault: '
+      '-Infinity, negativeInfinityDefault: -Infinity, doubleInfDefault: Infinity}'
     );
   }
 }

include/flatbuffers/util.h

@@ -393,6 +393,18 @@ inline uint64_t StringToUInt(const char *s, int base = 10) {
   return StringToIntegerImpl(&val, s, base) ? val : 0;
 }
 
+inline bool StringIsFlatbufferNan(const std::string &s) {
+  return s == "nan" || s == "+nan" || s == "-nan";
+}
+
+inline bool StringIsFlatbufferPositiveInfinity(const std::string &s) {
+  return s == "inf" || s == "+inf" || s == "infinity" || s == "+infinity";
+}
+
+inline bool StringIsFlatbufferNegativeInfinity(const std::string &s) {
+  return s == "-inf" || s == "-infinity";
+}
+
 typedef bool (*LoadFileFunction)(const char *filename, bool binary,
                                  std::string *dest);
 typedef bool (*FileExistsFunction)(const char *filename);

src/bfbs_gen_nim.cpp

@@ -470,6 +470,13 @@ class NimBfbsGenerator : public BaseBfbsGenerator {
   std::string DefaultValue(const r::Field *field) const {
     const r::BaseType base_type = field->type()->base_type();
     if (IsFloatingPoint(base_type)) {
+      if (field->default_real() != field->default_real()) {
+        return "NaN";
+      } else if (field->default_real() == std::numeric_limits<double>::infinity()) {
+        return "Inf";
+      } else if (field->default_real() == -std::numeric_limits<double>::infinity()) {
+        return "-Inf";
+      }
       return NumToString(field->default_real());
     }
     if (IsBool(base_type)) {

src/idl_gen_dart.cpp

@@ -16,6 +16,7 @@
 
 // independent from idl_parser, since this code is not needed for most clients
 #include <cassert>
+#include <cmath>
 
 #include "flatbuffers/code_generators.h"
 #include "flatbuffers/flatbuffers.h"
@@ -721,16 +722,17 @@ class DartGenerator : public BaseGenerator {
     if (!value.constant.empty() && value.constant != "0") {
       if (IsBool(value.type.base_type)) {
         return "true";
-      } else if (value.constant == "nan" || value.constant == "+nan" ||
-                 value.constant == "-nan") {
-        return "double.nan";
-      } else if (value.constant == "inf" || value.constant == "+inf") {
-        return "double.infinity";
-      } else if (value.constant == "-inf") {
-        return "double.negativeInfinity";
-      } else {
-        return value.constant;
       }
+      if (IsScalar(value.type.base_type)) {
+        if (StringIsFlatbufferNan(value.constant)) {
+          return "double.nan";
+        } else if (StringIsFlatbufferPositiveInfinity(value.constant)) {
+          return "double.infinity";
+        } else if (StringIsFlatbufferNegativeInfinity(value.constant)) {
+          return "double.negativeInfinity";
+        }
+      }
+      return value.constant;
     } else if (IsBool(value.type.base_type)) {
       return "false";
     } else if (IsScalar(value.type.base_type) && !IsUnion(value.type)) {

src/idl_gen_go.cpp

@@ -17,6 +17,7 @@
 // independent from idl_parser, since this code is not needed for most clients
 
 #include <algorithm>
+#include <cmath>
 #include <sstream>
 #include <string>
 
@@ -102,6 +103,7 @@ class GoGenerator : public BaseGenerator {
     for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
          ++it) {
       tracked_imported_namespaces_.clear();
+      needs_math_import_ = false;
       needs_imports = false;
       std::string enumcode;
       GenEnum(**it, &enumcode);
@@ -121,6 +123,7 @@ class GoGenerator : public BaseGenerator {
     for (auto it = parser_.structs_.vec.begin();
          it != parser_.structs_.vec.end(); ++it) {
       tracked_imported_namespaces_.clear();
+      needs_math_import_ = false;
       std::string declcode;
       GenStruct(**it, &declcode);
       if (parser_.opts.one_file) {
@@ -154,6 +157,7 @@ class GoGenerator : public BaseGenerator {
     }
   };
   std::set<const Namespace *, NamespacePtrLess> tracked_imported_namespaces_;
+  bool needs_math_import_ = false;
 
   // Most field accessors need to retrieve and test the field offset first,
   // this is the prefix code for that.
@@ -1277,6 +1281,23 @@ class GoGenerator : public BaseGenerator {
     switch (field.value.type.base_type) {
       case BASE_TYPE_BOOL:
         return field.value.constant == "0" ? "false" : "true";
+      case BASE_TYPE_FLOAT:
+      case BASE_TYPE_DOUBLE: {
+        const std::string float_type =
+            field.value.type.base_type == BASE_TYPE_FLOAT ? "float32"
+                                                          : "float64";
+        if (StringIsFlatbufferNan(field.value.constant)) {
+          needs_math_import_ = true;
+          return float_type + "(math.NaN())";
+        } else if (StringIsFlatbufferPositiveInfinity(field.value.constant)) {
+          needs_math_import_ = true;
+          return float_type + "(math.Inf(1))";
+        } else if (StringIsFlatbufferNegativeInfinity(field.value.constant)) {
+          needs_math_import_ = true;
+          return float_type + "(math.Inf(-1))";
+        }
+        return field.value.constant;
+      }
       default: return field.value.constant;
     }
   }
@@ -1330,6 +1351,8 @@ class GoGenerator : public BaseGenerator {
     if (needs_imports) {
       code += "import (\n";
       if (is_enum) { code += "\t\"strconv\"\n\n"; }
+      // math is needed to support non-finite scalar default values.
+      if (needs_math_import_) { code += "\t\"math\"\n\n"; }
       if (!parser_.opts.go_import.empty()) {
         code += "\tflatbuffers \"" + parser_.opts.go_import + "\"\n";
       } else {
@@ -1346,6 +1369,10 @@ class GoGenerator : public BaseGenerator {
       code += ")\n\n";
     } else {
       if (is_enum) { code += "import \"strconv\"\n\n"; }
+      if (needs_math_import_) {
+        // math is needed to support non-finite scalar default values.
+        code += "import \"math\"\n\n";
+      }
     }
   }
 

src/idl_gen_rust.cpp

@@ -16,6 +16,8 @@
 
 // independent from idl_parser, since this code is not needed for most clients
 
+#include <cmath>
+
 #include "flatbuffers/code_generators.h"
 #include "flatbuffers/flatbuffers.h"
 #include "flatbuffers/idl.h"
@@ -1046,8 +1048,19 @@ class RustGenerator : public BaseGenerator {
       if (field.IsOptional() && !IsUnion(field.value.type)) { return "None"; }
     }
     switch (GetFullType(field.value.type)) {
-      case ftInteger:
+      case ftInteger: {
+        return field.value.constant;
+      }
       case ftFloat: {
+        const std::string float_prefix =
+            (field.value.type.base_type == BASE_TYPE_FLOAT) ? "f32::" : "f64::";
+        if (StringIsFlatbufferNan(field.value.constant)) {
+          return float_prefix + "NAN";
+        } else if (StringIsFlatbufferPositiveInfinity(field.value.constant)) {
+          return float_prefix + "INFINITY";
+        } else if (StringIsFlatbufferNegativeInfinity(field.value.constant)) {
+          return float_prefix + "NEG_INFINITY";
+        }
         return field.value.constant;
       }
       case ftBool: {

src/idl_gen_ts.cpp

@@ -16,6 +16,7 @@
 
 #include <algorithm>
 #include <cassert>
+#include <cmath>
 #include <unordered_map>
 #include <unordered_set>
 
@@ -454,9 +455,16 @@ class TsGenerator : public BaseGenerator {
         return "BigInt('" + value.constant + "')";
       }
 
-      default:
+      default: {
-        if (value.constant == "nan") { return "NaN"; }
+        if (StringIsFlatbufferNan(value.constant)) {
+          return "NaN";
+        } else if (StringIsFlatbufferPositiveInfinity(value.constant)) {
+          return "Infinity";
+        } else if (StringIsFlatbufferNegativeInfinity(value.constant)) {
+          return "-Infinity";
+        }
         return value.constant;
+      }
     }
   }
 

tests/MyGame/Example/Monster.cs

@@ -215,6 +215,22 @@ public struct Monster : IFlatbufferObject
   public bool MutateLongEnumNonEnumDefault(MyGame.Example.LongEnum long_enum_non_enum_default) { int o = __p.__offset(108); if (o != 0) { __p.bb.PutUlong(o + __p.bb_pos, (ulong)long_enum_non_enum_default); return true; } else { return false; } }
   public MyGame.Example.LongEnum LongEnumNormalDefault { get { int o = __p.__offset(110); return o != 0 ? (MyGame.Example.LongEnum)__p.bb.GetUlong(o + __p.bb_pos) : MyGame.Example.LongEnum.LongOne; } }
   public bool MutateLongEnumNormalDefault(MyGame.Example.LongEnum long_enum_normal_default) { int o = __p.__offset(110); if (o != 0) { __p.bb.PutUlong(o + __p.bb_pos, (ulong)long_enum_normal_default); return true; } else { return false; } }
+  public float NanDefault { get { int o = __p.__offset(112); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)Single.NaN; } }
+  public bool MutateNanDefault(float nan_default) { int o = __p.__offset(112); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, nan_default); return true; } else { return false; } }
+  public float InfDefault { get { int o = __p.__offset(114); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)Single.PositiveInfinity; } }
+  public bool MutateInfDefault(float inf_default) { int o = __p.__offset(114); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, inf_default); return true; } else { return false; } }
+  public float PositiveInfDefault { get { int o = __p.__offset(116); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)Single.PositiveInfinity; } }
+  public bool MutatePositiveInfDefault(float positive_inf_default) { int o = __p.__offset(116); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, positive_inf_default); return true; } else { return false; } }
+  public float InfinityDefault { get { int o = __p.__offset(118); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)Single.PositiveInfinity; } }
+  public bool MutateInfinityDefault(float infinity_default) { int o = __p.__offset(118); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, infinity_default); return true; } else { return false; } }
+  public float PositiveInfinityDefault { get { int o = __p.__offset(120); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)Single.PositiveInfinity; } }
+  public bool MutatePositiveInfinityDefault(float positive_infinity_default) { int o = __p.__offset(120); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, positive_infinity_default); return true; } else { return false; } }
+  public float NegativeInfDefault { get { int o = __p.__offset(122); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)Single.NegativeInfinity; } }
+  public bool MutateNegativeInfDefault(float negative_inf_default) { int o = __p.__offset(122); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, negative_inf_default); return true; } else { return false; } }
+  public float NegativeInfinityDefault { get { int o = __p.__offset(124); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)Single.NegativeInfinity; } }
+  public bool MutateNegativeInfinityDefault(float negative_infinity_default) { int o = __p.__offset(124); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, negative_infinity_default); return true; } else { return false; } }
+  public double DoubleInfDefault { get { int o = __p.__offset(126); return o != 0 ? __p.bb.GetDouble(o + __p.bb_pos) : (double)Double.PositiveInfinity; } }
+  public bool MutateDoubleInfDefault(double double_inf_default) { int o = __p.__offset(126); if (o != 0) { __p.bb.PutDouble(o + __p.bb_pos, double_inf_default); return true; } else { return false; } }
 
   public static Offset<MyGame.Example.Monster> CreateMonster(FlatBufferBuilder builder,
       MyGame.Example.Vec3T pos = null,
@@ -269,8 +285,17 @@ public struct Monster : IFlatbufferObject
       VectorOffset scalar_key_sorted_tablesOffset = default(VectorOffset),
       MyGame.Example.TestT native_inline = null,
       MyGame.Example.LongEnum long_enum_non_enum_default = 0,
-      MyGame.Example.LongEnum long_enum_normal_default = MyGame.Example.LongEnum.LongOne) {
+      MyGame.Example.LongEnum long_enum_normal_default = MyGame.Example.LongEnum.LongOne,
-    builder.StartTable(54);
+      float nan_default = Single.NaN,
+      float inf_default = Single.PositiveInfinity,
+      float positive_inf_default = Single.PositiveInfinity,
+      float infinity_default = Single.PositiveInfinity,
+      float positive_infinity_default = Single.PositiveInfinity,
+      float negative_inf_default = Single.NegativeInfinity,
+      float negative_infinity_default = Single.NegativeInfinity,
+      double double_inf_default = Double.PositiveInfinity) {
+    builder.StartTable(62);
+    Monster.AddDoubleInfDefault(builder, double_inf_default);
     Monster.AddLongEnumNormalDefault(builder, long_enum_normal_default);
     Monster.AddLongEnumNonEnumDefault(builder, long_enum_non_enum_default);
     Monster.AddNonOwningReference(builder, non_owning_reference);
@@ -280,6 +305,13 @@ public struct Monster : IFlatbufferObject
     Monster.AddTesthashs64Fnv1a(builder, testhashs64_fnv1a);
     Monster.AddTesthashu64Fnv1(builder, testhashu64_fnv1);
     Monster.AddTesthashs64Fnv1(builder, testhashs64_fnv1);
+    Monster.AddNegativeInfinityDefault(builder, negative_infinity_default);
+    Monster.AddNegativeInfDefault(builder, negative_inf_default);
+    Monster.AddPositiveInfinityDefault(builder, positive_infinity_default);
+    Monster.AddInfinityDefault(builder, infinity_default);
+    Monster.AddPositiveInfDefault(builder, positive_inf_default);
+    Monster.AddInfDefault(builder, inf_default);
+    Monster.AddNanDefault(builder, nan_default);
     Monster.AddNativeInline(builder, MyGame.Example.Test.Pack(builder, native_inline));
     Monster.AddScalarKeySortedTables(builder, scalar_key_sorted_tablesOffset);
     Monster.AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbufferOffset);
@@ -327,7 +359,7 @@ public struct Monster : IFlatbufferObject
     return Monster.EndMonster(builder);
   }
 
-  public static void StartMonster(FlatBufferBuilder builder) { builder.StartTable(54); }
+  public static void StartMonster(FlatBufferBuilder builder) { builder.StartTable(62); }
   public static void AddPos(FlatBufferBuilder builder, Offset<MyGame.Example.Vec3> posOffset) { builder.AddStruct(0, posOffset.Value, 0); }
   public static void AddMana(FlatBufferBuilder builder, short mana) { builder.AddShort(1, mana, 150); }
   public static void AddHp(FlatBufferBuilder builder, short hp) { builder.AddShort(2, hp, 100); }
@@ -469,6 +501,14 @@ public struct Monster : IFlatbufferObject
   public static void AddNativeInline(FlatBufferBuilder builder, Offset<MyGame.Example.Test> nativeInlineOffset) { builder.AddStruct(51, nativeInlineOffset.Value, 0); }
   public static void AddLongEnumNonEnumDefault(FlatBufferBuilder builder, MyGame.Example.LongEnum longEnumNonEnumDefault) { builder.AddUlong(52, (ulong)longEnumNonEnumDefault, 0); }
   public static void AddLongEnumNormalDefault(FlatBufferBuilder builder, MyGame.Example.LongEnum longEnumNormalDefault) { builder.AddUlong(53, (ulong)longEnumNormalDefault, 2); }
+  public static void AddNanDefault(FlatBufferBuilder builder, float nanDefault) { builder.AddFloat(54, nanDefault, Single.NaN); }
+  public static void AddInfDefault(FlatBufferBuilder builder, float infDefault) { builder.AddFloat(55, infDefault, Single.PositiveInfinity); }
+  public static void AddPositiveInfDefault(FlatBufferBuilder builder, float positiveInfDefault) { builder.AddFloat(56, positiveInfDefault, Single.PositiveInfinity); }
+  public static void AddInfinityDefault(FlatBufferBuilder builder, float infinityDefault) { builder.AddFloat(57, infinityDefault, Single.PositiveInfinity); }
+  public static void AddPositiveInfinityDefault(FlatBufferBuilder builder, float positiveInfinityDefault) { builder.AddFloat(58, positiveInfinityDefault, Single.PositiveInfinity); }
+  public static void AddNegativeInfDefault(FlatBufferBuilder builder, float negativeInfDefault) { builder.AddFloat(59, negativeInfDefault, Single.NegativeInfinity); }
+  public static void AddNegativeInfinityDefault(FlatBufferBuilder builder, float negativeInfinityDefault) { builder.AddFloat(60, negativeInfinityDefault, Single.NegativeInfinity); }
+  public static void AddDoubleInfDefault(FlatBufferBuilder builder, double doubleInfDefault) { builder.AddDouble(61, doubleInfDefault, Double.PositiveInfinity); }
   public static Offset<MyGame.Example.Monster> EndMonster(FlatBufferBuilder builder) {
     int o = builder.EndTable();
     builder.Required(o, 10);  // name
@@ -620,6 +660,14 @@ public struct Monster : IFlatbufferObject
     _o.NativeInline = this.NativeInline.HasValue ? this.NativeInline.Value.UnPack() : null;
     _o.LongEnumNonEnumDefault = this.LongEnumNonEnumDefault;
     _o.LongEnumNormalDefault = this.LongEnumNormalDefault;
+    _o.NanDefault = this.NanDefault;
+    _o.InfDefault = this.InfDefault;
+    _o.PositiveInfDefault = this.PositiveInfDefault;
+    _o.InfinityDefault = this.InfinityDefault;
+    _o.PositiveInfinityDefault = this.PositiveInfinityDefault;
+    _o.NegativeInfDefault = this.NegativeInfDefault;
+    _o.NegativeInfinityDefault = this.NegativeInfinityDefault;
+    _o.DoubleInfDefault = this.DoubleInfDefault;
   }
   public static Offset<MyGame.Example.Monster> Pack(FlatBufferBuilder builder, MonsterT _o) {
     if (_o == null) return default(Offset<MyGame.Example.Monster>);
@@ -796,7 +844,15 @@ public struct Monster : IFlatbufferObject
       _scalar_key_sorted_tables,
       _o.NativeInline,
       _o.LongEnumNonEnumDefault,
-      _o.LongEnumNormalDefault);
+      _o.LongEnumNormalDefault,
+      _o.NanDefault,
+      _o.InfDefault,
+      _o.PositiveInfDefault,
+      _o.InfinityDefault,
+      _o.PositiveInfinityDefault,
+      _o.NegativeInfDefault,
+      _o.NegativeInfinityDefault,
+      _o.DoubleInfDefault);
   }
 }
 
@@ -949,6 +1005,22 @@ public class MonsterT
   public MyGame.Example.LongEnum LongEnumNonEnumDefault { get; set; }
   [Newtonsoft.Json.JsonProperty("long_enum_normal_default")]
   public MyGame.Example.LongEnum LongEnumNormalDefault { get; set; }
+  [Newtonsoft.Json.JsonProperty("nan_default")]
+  public float NanDefault { get; set; }
+  [Newtonsoft.Json.JsonProperty("inf_default")]
+  public float InfDefault { get; set; }
+  [Newtonsoft.Json.JsonProperty("positive_inf_default")]
+  public float PositiveInfDefault { get; set; }
+  [Newtonsoft.Json.JsonProperty("infinity_default")]
+  public float InfinityDefault { get; set; }
+  [Newtonsoft.Json.JsonProperty("positive_infinity_default")]
+  public float PositiveInfinityDefault { get; set; }
+  [Newtonsoft.Json.JsonProperty("negative_inf_default")]
+  public float NegativeInfDefault { get; set; }
+  [Newtonsoft.Json.JsonProperty("negative_infinity_default")]
+  public float NegativeInfinityDefault { get; set; }
+  [Newtonsoft.Json.JsonProperty("double_inf_default")]
+  public double DoubleInfDefault { get; set; }
 
   public MonsterT() {
     this.Pos = new MyGame.Example.Vec3T();
@@ -1001,6 +1073,14 @@ public class MonsterT
     this.NativeInline = new MyGame.Example.TestT();
     this.LongEnumNonEnumDefault = 0;
     this.LongEnumNormalDefault = MyGame.Example.LongEnum.LongOne;
+    this.NanDefault = Single.NaN;
+    this.InfDefault = Single.PositiveInfinity;
+    this.PositiveInfDefault = Single.PositiveInfinity;
+    this.InfinityDefault = Single.PositiveInfinity;
+    this.PositiveInfinityDefault = Single.PositiveInfinity;
+    this.NegativeInfDefault = Single.NegativeInfinity;
+    this.NegativeInfinityDefault = Single.NegativeInfinity;
+    this.DoubleInfDefault = Double.PositiveInfinity;
   }
 
   public static MonsterT DeserializeFromJson(string jsonText) {

tests/MyGame/Example/Monster.go

@@ -3,6 +3,8 @@
 package Example
 
 import (
+	"math"
+
 	flatbuffers "github.com/google/flatbuffers/go"
 
 	MyGame "MyGame"
@@ -60,6 +62,14 @@ type MonsterT struct {
 	NativeInline *TestT `json:"native_inline"`
 	LongEnumNonEnumDefault LongEnum `json:"long_enum_non_enum_default"`
 	LongEnumNormalDefault LongEnum `json:"long_enum_normal_default"`
+	NanDefault float32 `json:"nan_default"`
+	InfDefault float32 `json:"inf_default"`
+	PositiveInfDefault float32 `json:"positive_inf_default"`
+	InfinityDefault float32 `json:"infinity_default"`
+	PositiveInfinityDefault float32 `json:"positive_infinity_default"`
+	NegativeInfDefault float32 `json:"negative_inf_default"`
+	NegativeInfinityDefault float32 `json:"negative_infinity_default"`
+	DoubleInfDefault float64 `json:"double_inf_default"`
 }
 
 func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
@@ -320,6 +330,14 @@ func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
 	MonsterAddNativeInline(builder, nativeInlineOffset)
 	MonsterAddLongEnumNonEnumDefault(builder, t.LongEnumNonEnumDefault)
 	MonsterAddLongEnumNormalDefault(builder, t.LongEnumNormalDefault)
+	MonsterAddNanDefault(builder, t.NanDefault)
+	MonsterAddInfDefault(builder, t.InfDefault)
+	MonsterAddPositiveInfDefault(builder, t.PositiveInfDefault)
+	MonsterAddInfinityDefault(builder, t.InfinityDefault)
+	MonsterAddPositiveInfinityDefault(builder, t.PositiveInfinityDefault)
+	MonsterAddNegativeInfDefault(builder, t.NegativeInfDefault)
+	MonsterAddNegativeInfinityDefault(builder, t.NegativeInfinityDefault)
+	MonsterAddDoubleInfDefault(builder, t.DoubleInfDefault)
 	return MonsterEnd(builder)
 }
 
@@ -461,6 +479,14 @@ func (rcv *Monster) UnPackTo(t *MonsterT) {
 	t.NativeInline = rcv.NativeInline(nil).UnPack()
 	t.LongEnumNonEnumDefault = rcv.LongEnumNonEnumDefault()
 	t.LongEnumNormalDefault = rcv.LongEnumNormalDefault()
+	t.NanDefault = rcv.NanDefault()
+	t.InfDefault = rcv.InfDefault()
+	t.PositiveInfDefault = rcv.PositiveInfDefault()
+	t.InfinityDefault = rcv.InfinityDefault()
+	t.PositiveInfinityDefault = rcv.PositiveInfinityDefault()
+	t.NegativeInfDefault = rcv.NegativeInfDefault()
+	t.NegativeInfinityDefault = rcv.NegativeInfinityDefault()
+	t.DoubleInfDefault = rcv.DoubleInfDefault()
 }
 
 func (rcv *Monster) UnPack() *MonsterT {
@@ -1386,8 +1412,104 @@ func (rcv *Monster) MutateLongEnumNormalDefault(n LongEnum) bool {
 	return rcv._tab.MutateUint64Slot(110, uint64(n))
 }
 
+func (rcv *Monster) NanDefault() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(112))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return float32(math.NaN())
+}
+
+func (rcv *Monster) MutateNanDefault(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(112, n)
+}
+
+func (rcv *Monster) InfDefault() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(114))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return float32(math.Inf(1))
+}
+
+func (rcv *Monster) MutateInfDefault(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(114, n)
+}
+
+func (rcv *Monster) PositiveInfDefault() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(116))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return float32(math.Inf(1))
+}
+
+func (rcv *Monster) MutatePositiveInfDefault(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(116, n)
+}
+
+func (rcv *Monster) InfinityDefault() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(118))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return float32(math.Inf(1))
+}
+
+func (rcv *Monster) MutateInfinityDefault(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(118, n)
+}
+
+func (rcv *Monster) PositiveInfinityDefault() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(120))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return float32(math.Inf(1))
+}
+
+func (rcv *Monster) MutatePositiveInfinityDefault(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(120, n)
+}
+
+func (rcv *Monster) NegativeInfDefault() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(122))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return float32(math.Inf(-1))
+}
+
+func (rcv *Monster) MutateNegativeInfDefault(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(122, n)
+}
+
+func (rcv *Monster) NegativeInfinityDefault() float32 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(124))
+	if o != 0 {
+		return rcv._tab.GetFloat32(o + rcv._tab.Pos)
+	}
+	return float32(math.Inf(-1))
+}
+
+func (rcv *Monster) MutateNegativeInfinityDefault(n float32) bool {
+	return rcv._tab.MutateFloat32Slot(124, n)
+}
+
+func (rcv *Monster) DoubleInfDefault() float64 {
+	o := flatbuffers.UOffsetT(rcv._tab.Offset(126))
+	if o != 0 {
+		return rcv._tab.GetFloat64(o + rcv._tab.Pos)
+	}
+	return float64(math.Inf(1))
+}
+
+func (rcv *Monster) MutateDoubleInfDefault(n float64) bool {
+	return rcv._tab.MutateFloat64Slot(126, n)
+}
+
 func MonsterStart(builder *flatbuffers.Builder) {
-	builder.StartObject(54)
+	builder.StartObject(62)
 }
 func MonsterAddPos(builder *flatbuffers.Builder, pos flatbuffers.UOffsetT) {
 	builder.PrependStructSlot(0, flatbuffers.UOffsetT(pos), 0)
@@ -1608,6 +1730,30 @@ func MonsterAddLongEnumNonEnumDefault(builder *flatbuffers.Builder, longEnumNonE
 func MonsterAddLongEnumNormalDefault(builder *flatbuffers.Builder, longEnumNormalDefault LongEnum) {
 	builder.PrependUint64Slot(53, uint64(longEnumNormalDefault), 2)
 }
+func MonsterAddNanDefault(builder *flatbuffers.Builder, nanDefault float32) {
+	builder.PrependFloat32Slot(54, nanDefault, float32(math.NaN()))
+}
+func MonsterAddInfDefault(builder *flatbuffers.Builder, infDefault float32) {
+	builder.PrependFloat32Slot(55, infDefault, float32(math.Inf(1)))
+}
+func MonsterAddPositiveInfDefault(builder *flatbuffers.Builder, positiveInfDefault float32) {
+	builder.PrependFloat32Slot(56, positiveInfDefault, float32(math.Inf(1)))
+}
+func MonsterAddInfinityDefault(builder *flatbuffers.Builder, infinityDefault float32) {
+	builder.PrependFloat32Slot(57, infinityDefault, float32(math.Inf(1)))
+}
+func MonsterAddPositiveInfinityDefault(builder *flatbuffers.Builder, positiveInfinityDefault float32) {
+	builder.PrependFloat32Slot(58, positiveInfinityDefault, float32(math.Inf(1)))
+}
+func MonsterAddNegativeInfDefault(builder *flatbuffers.Builder, negativeInfDefault float32) {
+	builder.PrependFloat32Slot(59, negativeInfDefault, float32(math.Inf(-1)))
+}
+func MonsterAddNegativeInfinityDefault(builder *flatbuffers.Builder, negativeInfinityDefault float32) {
+	builder.PrependFloat32Slot(60, negativeInfinityDefault, float32(math.Inf(-1)))
+}
+func MonsterAddDoubleInfDefault(builder *flatbuffers.Builder, doubleInfDefault float64) {
+	builder.PrependFloat64Slot(61, doubleInfDefault, float64(math.Inf(1)))
+}
 func MonsterEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
 	return builder.EndObject()
 }

tests/MyGame/Example/Monster.java

@@ -216,8 +216,24 @@ public final class Monster extends Table {
   public boolean mutateLongEnumNonEnumDefault(long long_enum_non_enum_default) { int o = __offset(108); if (o != 0) { bb.putLong(o + bb_pos, long_enum_non_enum_default); return true; } else { return false; } }
   public long longEnumNormalDefault() { int o = __offset(110); return o != 0 ? bb.getLong(o + bb_pos) : 2L; }
   public boolean mutateLongEnumNormalDefault(long long_enum_normal_default) { int o = __offset(110); if (o != 0) { bb.putLong(o + bb_pos, long_enum_normal_default); return true; } else { return false; } }
+  public float nanDefault() { int o = __offset(112); return o != 0 ? bb.getFloat(o + bb_pos) : Float.NaN; }
+  public boolean mutateNanDefault(float nan_default) { int o = __offset(112); if (o != 0) { bb.putFloat(o + bb_pos, nan_default); return true; } else { return false; } }
+  public float infDefault() { int o = __offset(114); return o != 0 ? bb.getFloat(o + bb_pos) : Float.POSITIVE_INFINITY; }
+  public boolean mutateInfDefault(float inf_default) { int o = __offset(114); if (o != 0) { bb.putFloat(o + bb_pos, inf_default); return true; } else { return false; } }
+  public float positiveInfDefault() { int o = __offset(116); return o != 0 ? bb.getFloat(o + bb_pos) : Float.POSITIVE_INFINITY; }
+  public boolean mutatePositiveInfDefault(float positive_inf_default) { int o = __offset(116); if (o != 0) { bb.putFloat(o + bb_pos, positive_inf_default); return true; } else { return false; } }
+  public float infinityDefault() { int o = __offset(118); return o != 0 ? bb.getFloat(o + bb_pos) : Float.POSITIVE_INFINITY; }
+  public boolean mutateInfinityDefault(float infinity_default) { int o = __offset(118); if (o != 0) { bb.putFloat(o + bb_pos, infinity_default); return true; } else { return false; } }
+  public float positiveInfinityDefault() { int o = __offset(120); return o != 0 ? bb.getFloat(o + bb_pos) : Float.POSITIVE_INFINITY; }
+  public boolean mutatePositiveInfinityDefault(float positive_infinity_default) { int o = __offset(120); if (o != 0) { bb.putFloat(o + bb_pos, positive_infinity_default); return true; } else { return false; } }
+  public float negativeInfDefault() { int o = __offset(122); return o != 0 ? bb.getFloat(o + bb_pos) : Float.NEGATIVE_INFINITY; }
+  public boolean mutateNegativeInfDefault(float negative_inf_default) { int o = __offset(122); if (o != 0) { bb.putFloat(o + bb_pos, negative_inf_default); return true; } else { return false; } }
+  public float negativeInfinityDefault() { int o = __offset(124); return o != 0 ? bb.getFloat(o + bb_pos) : Float.NEGATIVE_INFINITY; }
+  public boolean mutateNegativeInfinityDefault(float negative_infinity_default) { int o = __offset(124); if (o != 0) { bb.putFloat(o + bb_pos, negative_infinity_default); return true; } else { return false; } }
+  public double doubleInfDefault() { int o = __offset(126); return o != 0 ? bb.getDouble(o + bb_pos) : Double.POSITIVE_INFINITY; }
+  public boolean mutateDoubleInfDefault(double double_inf_default) { int o = __offset(126); if (o != 0) { bb.putDouble(o + bb_pos, double_inf_default); return true; } else { return false; } }
 
-  public static void startMonster(FlatBufferBuilder builder) { builder.startTable(54); }
+  public static void startMonster(FlatBufferBuilder builder) { builder.startTable(62); }
   public static void addPos(FlatBufferBuilder builder, int posOffset) { builder.addStruct(0, posOffset, 0); }
   public static void addMana(FlatBufferBuilder builder, short mana) { builder.addShort(1, mana, 150); }
   public static void addHp(FlatBufferBuilder builder, short hp) { builder.addShort(2, hp, 100); }
@@ -313,6 +329,14 @@ public final class Monster extends Table {
   public static void addNativeInline(FlatBufferBuilder builder, int nativeInlineOffset) { builder.addStruct(51, nativeInlineOffset, 0); }
   public static void addLongEnumNonEnumDefault(FlatBufferBuilder builder, long longEnumNonEnumDefault) { builder.addLong(52, longEnumNonEnumDefault, 0L); }
   public static void addLongEnumNormalDefault(FlatBufferBuilder builder, long longEnumNormalDefault) { builder.addLong(53, longEnumNormalDefault, 2L); }
+  public static void addNanDefault(FlatBufferBuilder builder, float nanDefault) { builder.addFloat(54, nanDefault, Float.NaN); }
+  public static void addInfDefault(FlatBufferBuilder builder, float infDefault) { builder.addFloat(55, infDefault, Float.POSITIVE_INFINITY); }
+  public static void addPositiveInfDefault(FlatBufferBuilder builder, float positiveInfDefault) { builder.addFloat(56, positiveInfDefault, Float.POSITIVE_INFINITY); }
+  public static void addInfinityDefault(FlatBufferBuilder builder, float infinityDefault) { builder.addFloat(57, infinityDefault, Float.POSITIVE_INFINITY); }
+  public static void addPositiveInfinityDefault(FlatBufferBuilder builder, float positiveInfinityDefault) { builder.addFloat(58, positiveInfinityDefault, Float.POSITIVE_INFINITY); }
+  public static void addNegativeInfDefault(FlatBufferBuilder builder, float negativeInfDefault) { builder.addFloat(59, negativeInfDefault, Float.NEGATIVE_INFINITY); }
+  public static void addNegativeInfinityDefault(FlatBufferBuilder builder, float negativeInfinityDefault) { builder.addFloat(60, negativeInfinityDefault, Float.NEGATIVE_INFINITY); }
+  public static void addDoubleInfDefault(FlatBufferBuilder builder, double doubleInfDefault) { builder.addDouble(61, doubleInfDefault, Double.POSITIVE_INFINITY); }
   public static int endMonster(FlatBufferBuilder builder) {
     int o = builder.endTable();
     builder.required(o, 10);  // name
@@ -533,6 +557,22 @@ public final class Monster extends Table {
     _o.setLongEnumNonEnumDefault(_oLongEnumNonEnumDefault);
     long _oLongEnumNormalDefault = longEnumNormalDefault();
     _o.setLongEnumNormalDefault(_oLongEnumNormalDefault);
+    float _oNanDefault = nanDefault();
+    _o.setNanDefault(_oNanDefault);
+    float _oInfDefault = infDefault();
+    _o.setInfDefault(_oInfDefault);
+    float _oPositiveInfDefault = positiveInfDefault();
+    _o.setPositiveInfDefault(_oPositiveInfDefault);
+    float _oInfinityDefault = infinityDefault();
+    _o.setInfinityDefault(_oInfinityDefault);
+    float _oPositiveInfinityDefault = positiveInfinityDefault();
+    _o.setPositiveInfinityDefault(_oPositiveInfinityDefault);
+    float _oNegativeInfDefault = negativeInfDefault();
+    _o.setNegativeInfDefault(_oNegativeInfDefault);
+    float _oNegativeInfinityDefault = negativeInfinityDefault();
+    _o.setNegativeInfinityDefault(_oNegativeInfinityDefault);
+    double _oDoubleInfDefault = doubleInfDefault();
+    _o.setDoubleInfDefault(_oDoubleInfDefault);
   }
   public static int pack(FlatBufferBuilder builder, MonsterT _o) {
     if (_o == null) return 0;
@@ -725,6 +765,14 @@ public final class Monster extends Table {
     addNativeInline(builder, MyGame.Example.Test.pack(builder, _o.getNativeInline()));
     addLongEnumNonEnumDefault(builder, _o.getLongEnumNonEnumDefault());
     addLongEnumNormalDefault(builder, _o.getLongEnumNormalDefault());
+    addNanDefault(builder, _o.getNanDefault());
+    addInfDefault(builder, _o.getInfDefault());
+    addPositiveInfDefault(builder, _o.getPositiveInfDefault());
+    addInfinityDefault(builder, _o.getInfinityDefault());
+    addPositiveInfinityDefault(builder, _o.getPositiveInfinityDefault());
+    addNegativeInfDefault(builder, _o.getNegativeInfDefault());
+    addNegativeInfinityDefault(builder, _o.getNegativeInfinityDefault());
+    addDoubleInfDefault(builder, _o.getDoubleInfDefault());
     return endMonster(builder);
   }
 }

tests/MyGame/Example/Monster.kt

@@ -870,6 +870,118 @@ class Monster : Table() {
             false
         }
     }
+    val nanDefault : Float
+        get() {
+            val o = __offset(112)
+            return if(o != 0) bb.getFloat(o + bb_pos) else Float.NaN
+        }
+    fun mutateNanDefault(nanDefault: Float) : Boolean {
+        val o = __offset(112)
+        return if (o != 0) {
+            bb.putFloat(o + bb_pos, nanDefault)
+            true
+        } else {
+            false
+        }
+    }
+    val infDefault : Float
+        get() {
+            val o = __offset(114)
+            return if(o != 0) bb.getFloat(o + bb_pos) else Float.POSITIVE_INFINITY
+        }
+    fun mutateInfDefault(infDefault: Float) : Boolean {
+        val o = __offset(114)
+        return if (o != 0) {
+            bb.putFloat(o + bb_pos, infDefault)
+            true
+        } else {
+            false
+        }
+    }
+    val positiveInfDefault : Float
+        get() {
+            val o = __offset(116)
+            return if(o != 0) bb.getFloat(o + bb_pos) else Float.POSITIVE_INFINITY
+        }
+    fun mutatePositiveInfDefault(positiveInfDefault: Float) : Boolean {
+        val o = __offset(116)
+        return if (o != 0) {
+            bb.putFloat(o + bb_pos, positiveInfDefault)
+            true
+        } else {
+            false
+        }
+    }
+    val infinityDefault : Float
+        get() {
+            val o = __offset(118)
+            return if(o != 0) bb.getFloat(o + bb_pos) else Float.POSITIVE_INFINITY
+        }
+    fun mutateInfinityDefault(infinityDefault: Float) : Boolean {
+        val o = __offset(118)
+        return if (o != 0) {
+            bb.putFloat(o + bb_pos, infinityDefault)
+            true
+        } else {
+            false
+        }
+    }
+    val positiveInfinityDefault : Float
+        get() {
+            val o = __offset(120)
+            return if(o != 0) bb.getFloat(o + bb_pos) else Float.POSITIVE_INFINITY
+        }
+    fun mutatePositiveInfinityDefault(positiveInfinityDefault: Float) : Boolean {
+        val o = __offset(120)
+        return if (o != 0) {
+            bb.putFloat(o + bb_pos, positiveInfinityDefault)
+            true
+        } else {
+            false
+        }
+    }
+    val negativeInfDefault : Float
+        get() {
+            val o = __offset(122)
+            return if(o != 0) bb.getFloat(o + bb_pos) else Float.NEGATIVE_INFINITY
+        }
+    fun mutateNegativeInfDefault(negativeInfDefault: Float) : Boolean {
+        val o = __offset(122)
+        return if (o != 0) {
+            bb.putFloat(o + bb_pos, negativeInfDefault)
+            true
+        } else {
+            false
+        }
+    }
+    val negativeInfinityDefault : Float
+        get() {
+            val o = __offset(124)
+            return if(o != 0) bb.getFloat(o + bb_pos) else Float.NEGATIVE_INFINITY
+        }
+    fun mutateNegativeInfinityDefault(negativeInfinityDefault: Float) : Boolean {
+        val o = __offset(124)
+        return if (o != 0) {
+            bb.putFloat(o + bb_pos, negativeInfinityDefault)
+            true
+        } else {
+            false
+        }
+    }
+    val doubleInfDefault : Double
+        get() {
+            val o = __offset(126)
+            return if(o != 0) bb.getDouble(o + bb_pos) else Double.POSITIVE_INFINITY
+        }
+    fun mutateDoubleInfDefault(doubleInfDefault: Double) : Boolean {
+        val o = __offset(126)
+        return if (o != 0) {
+            bb.putDouble(o + bb_pos, doubleInfDefault)
+            true
+        } else {
+            false
+        }
+    }
     override fun keysCompare(o1: Int, o2: Int, _bb: ByteBuffer) : Int {
          return compareStrings(__offset(10, o1, _bb), __offset(10, o2, _bb), _bb)
     }
@@ -881,7 +993,7 @@ class Monster : Table() {
             return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
         }
         fun MonsterBufferHasIdentifier(_bb: ByteBuffer) : Boolean = __has_identifier(_bb, "MONS")
-        fun startMonster(builder: FlatBufferBuilder) = builder.startTable(54)
+        fun startMonster(builder: FlatBufferBuilder) = builder.startTable(62)
         fun addPos(builder: FlatBufferBuilder, pos: Int) = builder.addStruct(0, pos, 0)
         fun addMana(builder: FlatBufferBuilder, mana: Short) = builder.addShort(1, mana, 150)
         fun addHp(builder: FlatBufferBuilder, hp: Short) = builder.addShort(2, hp, 100)
@@ -1077,6 +1189,14 @@ class Monster : Table() {
         fun addNativeInline(builder: FlatBufferBuilder, nativeInline: Int) = builder.addStruct(51, nativeInline, 0)
         fun addLongEnumNonEnumDefault(builder: FlatBufferBuilder, longEnumNonEnumDefault: ULong) = builder.addLong(52, longEnumNonEnumDefault.toLong(), 0)
         fun addLongEnumNormalDefault(builder: FlatBufferBuilder, longEnumNormalDefault: ULong) = builder.addLong(53, longEnumNormalDefault.toLong(), 2)
+        fun addNanDefault(builder: FlatBufferBuilder, nanDefault: Float) = builder.addFloat(54, nanDefault, Double.NaN)
+        fun addInfDefault(builder: FlatBufferBuilder, infDefault: Float) = builder.addFloat(55, infDefault, Double.POSITIVE_INFINITY)
+        fun addPositiveInfDefault(builder: FlatBufferBuilder, positiveInfDefault: Float) = builder.addFloat(56, positiveInfDefault, Double.POSITIVE_INFINITY)
+        fun addInfinityDefault(builder: FlatBufferBuilder, infinityDefault: Float) = builder.addFloat(57, infinityDefault, Double.POSITIVE_INFINITY)
+        fun addPositiveInfinityDefault(builder: FlatBufferBuilder, positiveInfinityDefault: Float) = builder.addFloat(58, positiveInfinityDefault, Double.POSITIVE_INFINITY)
+        fun addNegativeInfDefault(builder: FlatBufferBuilder, negativeInfDefault: Float) = builder.addFloat(59, negativeInfDefault, Double.NEGATIVE_INFINITY)
+        fun addNegativeInfinityDefault(builder: FlatBufferBuilder, negativeInfinityDefault: Float) = builder.addFloat(60, negativeInfinityDefault, Double.NEGATIVE_INFINITY)
+        fun addDoubleInfDefault(builder: FlatBufferBuilder, doubleInfDefault: Double) = builder.addDouble(61, doubleInfDefault, Double.POSITIVE_INFINITY)
         fun endMonster(builder: FlatBufferBuilder) : Int {
             val o = builder.endTable()
                 builder.required(o, 10)

tests/MyGame/Example/Monster.lua

@@ -703,8 +703,72 @@ function mt:LongEnumNormalDefault()
   return 2
 end
 
+function mt:NanDefault()
+  local o = self.view:Offset(112)
+  if o ~= 0 then
+    return self.view:Get(flatbuffers.N.Float32, self.view.pos + o)
+  end
+  return nan
+end
+
+function mt:InfDefault()
+  local o = self.view:Offset(114)
+  if o ~= 0 then
+    return self.view:Get(flatbuffers.N.Float32, self.view.pos + o)
+  end
+  return inf
+end
+
+function mt:PositiveInfDefault()
+  local o = self.view:Offset(116)
+  if o ~= 0 then
+    return self.view:Get(flatbuffers.N.Float32, self.view.pos + o)
+  end
+  return inf
+end
+
+function mt:InfinityDefault()
+  local o = self.view:Offset(118)
+  if o ~= 0 then
+    return self.view:Get(flatbuffers.N.Float32, self.view.pos + o)
+  end
+  return inf
+end
+
+function mt:PositiveInfinityDefault()
+  local o = self.view:Offset(120)
+  if o ~= 0 then
+    return self.view:Get(flatbuffers.N.Float32, self.view.pos + o)
+  end
+  return inf
+end
+
+function mt:NegativeInfDefault()
+  local o = self.view:Offset(122)
+  if o ~= 0 then
+    return self.view:Get(flatbuffers.N.Float32, self.view.pos + o)
+  end
+  return -inf
+end
+
+function mt:NegativeInfinityDefault()
+  local o = self.view:Offset(124)
+  if o ~= 0 then
+    return self.view:Get(flatbuffers.N.Float32, self.view.pos + o)
+  end
+  return -inf
+end
+
+function mt:DoubleInfDefault()
+  local o = self.view:Offset(126)
+  if o ~= 0 then
+    return self.view:Get(flatbuffers.N.Float64, self.view.pos + o)
+  end
+  return inf
+end
+
 function Monster.Start(builder)
-  builder:StartObject(54)
+  builder:StartObject(62)
 end
 
 function Monster.AddPos(builder, pos)
@@ -999,6 +1063,38 @@ function Monster.AddLongEnumNormalDefault(builder, longEnumNormalDefault)
   builder:PrependUint64Slot(53, longEnumNormalDefault, 2)
 end
 
+function Monster.AddNanDefault(builder, nanDefault)
+  builder:PrependFloat32Slot(54, nanDefault, nan)
+end
+
+function Monster.AddInfDefault(builder, infDefault)
+  builder:PrependFloat32Slot(55, infDefault, inf)
+end
+
+function Monster.AddPositiveInfDefault(builder, positiveInfDefault)
+  builder:PrependFloat32Slot(56, positiveInfDefault, inf)
+end
+
+function Monster.AddInfinityDefault(builder, infinityDefault)
+  builder:PrependFloat32Slot(57, infinityDefault, inf)
+end
+
+function Monster.AddPositiveInfinityDefault(builder, positiveInfinityDefault)
+  builder:PrependFloat32Slot(58, positiveInfinityDefault, inf)
+end
+
+function Monster.AddNegativeInfDefault(builder, negativeInfDefault)
+  builder:PrependFloat32Slot(59, negativeInfDefault, -inf)
+end
+
+function Monster.AddNegativeInfinityDefault(builder, negativeInfinityDefault)
+  builder:PrependFloat32Slot(60, negativeInfinityDefault, -inf)
+end
+
+function Monster.AddDoubleInfDefault(builder, doubleInfDefault)
+  builder:PrependFloat64Slot(61, doubleInfDefault, inf)
+end
+
 function Monster.End(builder)
   return builder:EndObject()
 end

tests/MyGame/Example/Monster.nim

@@ -510,8 +510,64 @@ func longEnumNormalDefault*(self: Monster): MyGame_Example_LongEnum.LongEnum =
   return type(result)(2)
 func `longEnumNormalDefault=`*(self: var Monster, n: MyGame_Example_LongEnum.LongEnum): bool =
   return self.tab.MutateSlot(110, n)
+func nanDefault*(self: Monster): float32 =
+  let o = self.tab.Offset(112)
+  if o != 0:
+    return Get[float32](self.tab, self.tab.Pos + o)
+  return NaN
+func `nanDefault=`*(self: var Monster, n: float32): bool =
+  return self.tab.MutateSlot(112, n)
+func infDefault*(self: Monster): float32 =
+  let o = self.tab.Offset(114)
+  if o != 0:
+    return Get[float32](self.tab, self.tab.Pos + o)
+  return Inf
+func `infDefault=`*(self: var Monster, n: float32): bool =
+  return self.tab.MutateSlot(114, n)
+func positiveInfDefault*(self: Monster): float32 =
+  let o = self.tab.Offset(116)
+  if o != 0:
+    return Get[float32](self.tab, self.tab.Pos + o)
+  return Inf
+func `positiveInfDefault=`*(self: var Monster, n: float32): bool =
+  return self.tab.MutateSlot(116, n)
+func infinityDefault*(self: Monster): float32 =
+  let o = self.tab.Offset(118)
+  if o != 0:
+    return Get[float32](self.tab, self.tab.Pos + o)
+  return Inf
+func `infinityDefault=`*(self: var Monster, n: float32): bool =
+  return self.tab.MutateSlot(118, n)
+func positiveInfinityDefault*(self: Monster): float32 =
+  let o = self.tab.Offset(120)
+  if o != 0:
+    return Get[float32](self.tab, self.tab.Pos + o)
+  return Inf
+func `positiveInfinityDefault=`*(self: var Monster, n: float32): bool =
+  return self.tab.MutateSlot(120, n)
+func negativeInfDefault*(self: Monster): float32 =
+  let o = self.tab.Offset(122)
+  if o != 0:
+    return Get[float32](self.tab, self.tab.Pos + o)
+  return -Inf
+func `negativeInfDefault=`*(self: var Monster, n: float32): bool =
+  return self.tab.MutateSlot(122, n)
+func negativeInfinityDefault*(self: Monster): float32 =
+  let o = self.tab.Offset(124)
+  if o != 0:
+    return Get[float32](self.tab, self.tab.Pos + o)
+  return -Inf
+func `negativeInfinityDefault=`*(self: var Monster, n: float32): bool =
+  return self.tab.MutateSlot(124, n)
+func doubleInfDefault*(self: Monster): float64 =
+  let o = self.tab.Offset(126)
+  if o != 0:
+    return Get[float64](self.tab, self.tab.Pos + o)
+  return Inf
+func `doubleInfDefault=`*(self: var Monster, n: float64): bool =
+  return self.tab.MutateSlot(126, n)
 proc MonsterStart*(builder: var Builder) =
-  builder.StartObject(54)
+  builder.StartObject(62)
 proc MonsterAddpos*(builder: var Builder, pos: uoffset) =
   builder.PrependStructSlot(0, pos, default(uoffset))
 proc MonsterAddmana*(builder: var Builder, mana: int16) =
@@ -658,5 +714,21 @@ proc MonsterAddlongEnumNonEnumDefault*(builder: var Builder, longEnumNonEnumDefa
   builder.PrependSlot(52, longEnumNonEnumDefault, default(uint64))
 proc MonsterAddlongEnumNormalDefault*(builder: var Builder, longEnumNormalDefault: uint64) =
   builder.PrependSlot(53, longEnumNormalDefault, default(uint64))
+proc MonsterAddnanDefault*(builder: var Builder, nanDefault: float32) =
+  builder.PrependSlot(54, nanDefault, default(float32))
+proc MonsterAddinfDefault*(builder: var Builder, infDefault: float32) =
+  builder.PrependSlot(55, infDefault, default(float32))
+proc MonsterAddpositiveInfDefault*(builder: var Builder, positiveInfDefault: float32) =
+  builder.PrependSlot(56, positiveInfDefault, default(float32))
+proc MonsterAddinfinityDefault*(builder: var Builder, infinityDefault: float32) =
+  builder.PrependSlot(57, infinityDefault, default(float32))
+proc MonsterAddpositiveInfinityDefault*(builder: var Builder, positiveInfinityDefault: float32) =
+  builder.PrependSlot(58, positiveInfinityDefault, default(float32))
+proc MonsterAddnegativeInfDefault*(builder: var Builder, negativeInfDefault: float32) =
+  builder.PrependSlot(59, negativeInfDefault, default(float32))
+proc MonsterAddnegativeInfinityDefault*(builder: var Builder, negativeInfinityDefault: float32) =
+  builder.PrependSlot(60, negativeInfinityDefault, default(float32))
+proc MonsterAdddoubleInfDefault*(builder: var Builder, doubleInfDefault: float64) =
+  builder.PrependSlot(61, doubleInfDefault, default(float64))
 proc MonsterEnd*(builder: var Builder): uoffset =
   return builder.EndObject()

tests/MyGame/Example/Monster.php

@@ -754,22 +754,94 @@ class Monster extends Table
         return $o != 0 ? $this->bb->getUlong($o + $this->bb_pos) : \MyGame\Example\LongEnum::LongOne;
     }
 
+    /**
+     * @return float
+     */
+    public function getNanDefault()
+    {
+        $o = $this->__offset(112);
+        return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : nan;
+    }
+
+    /**
+     * @return float
+     */
+    public function getInfDefault()
+    {
+        $o = $this->__offset(114);
+        return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : inf;
+    }
+
+    /**
+     * @return float
+     */
+    public function getPositiveInfDefault()
+    {
+        $o = $this->__offset(116);
+        return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : +inf;
+    }
+
+    /**
+     * @return float
+     */
+    public function getInfinityDefault()
+    {
+        $o = $this->__offset(118);
+        return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : infinity;
+    }
+
+    /**
+     * @return float
+     */
+    public function getPositiveInfinityDefault()
+    {
+        $o = $this->__offset(120);
+        return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : +infinity;
+    }
+
+    /**
+     * @return float
+     */
+    public function getNegativeInfDefault()
+    {
+        $o = $this->__offset(122);
+        return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : -inf;
+    }
+
+    /**
+     * @return float
+     */
+    public function getNegativeInfinityDefault()
+    {
+        $o = $this->__offset(124);
+        return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : -infinity;
+    }
+
+    /**
+     * @return double
+     */
+    public function getDoubleInfDefault()
+    {
+        $o = $this->__offset(126);
+        return $o != 0 ? $this->bb->getDouble($o + $this->bb_pos) : inf;
+    }
+
     /**
      * @param FlatBufferBuilder $builder
      * @return void
      */
     public static function startMonster(FlatBufferBuilder $builder)
     {
-        $builder->StartObject(54);
+        $builder->StartObject(62);
     }
 
     /**
      * @param FlatBufferBuilder $builder
      * @return Monster
      */
-    public static function createMonster(FlatBufferBuilder $builder, $pos, $mana, $hp, $name, $inventory, $color, $test_type, $test, $test4, $testarrayofstring, $testarrayoftables, $enemy, $testnestedflatbuffer, $testempty, $testbool, $testhashs32_fnv1, $testhashu32_fnv1, $testhashs64_fnv1, $testhashu64_fnv1, $testhashs32_fnv1a, $testhashu32_fnv1a, $testhashs64_fnv1a, $testhashu64_fnv1a, $testarrayofbools, $testf, $testf2, $testf3, $testarrayofstring2, $testarrayofsortedstruct, $flex, $test5, $vector_of_longs, $vector_of_doubles, $parent_namespace_test, $vector_of_referrables, $single_weak_reference, $vector_of_weak_references, $vector_of_strong_referrables, $co_owning_reference, $vector_of_co_owning_references, $non_owning_reference, $vector_of_non_owning_references, $any_unique_type, $any_unique, $any_ambiguous_type, $any_ambiguous, $vector_of_enums, $signed_enum, $testrequirednestedflatbuffer, $scalar_key_sorted_tables, $native_inline, $long_enum_non_enum_default, $long_enum_normal_default)
+    public static function createMonster(FlatBufferBuilder $builder, $pos, $mana, $hp, $name, $inventory, $color, $test_type, $test, $test4, $testarrayofstring, $testarrayoftables, $enemy, $testnestedflatbuffer, $testempty, $testbool, $testhashs32_fnv1, $testhashu32_fnv1, $testhashs64_fnv1, $testhashu64_fnv1, $testhashs32_fnv1a, $testhashu32_fnv1a, $testhashs64_fnv1a, $testhashu64_fnv1a, $testarrayofbools, $testf, $testf2, $testf3, $testarrayofstring2, $testarrayofsortedstruct, $flex, $test5, $vector_of_longs, $vector_of_doubles, $parent_namespace_test, $vector_of_referrables, $single_weak_reference, $vector_of_weak_references, $vector_of_strong_referrables, $co_owning_reference, $vector_of_co_owning_references, $non_owning_reference, $vector_of_non_owning_references, $any_unique_type, $any_unique, $any_ambiguous_type, $any_ambiguous, $vector_of_enums, $signed_enum, $testrequirednestedflatbuffer, $scalar_key_sorted_tables, $native_inline, $long_enum_non_enum_default, $long_enum_normal_default, $nan_default, $inf_default, $positive_inf_default, $infinity_default, $positive_infinity_default, $negative_inf_default, $negative_infinity_default, $double_inf_default)
     {
-        $builder->startObject(54);
+        $builder->startObject(62);
         self::addPos($builder, $pos);
         self::addMana($builder, $mana);
         self::addHp($builder, $hp);
@@ -823,6 +895,14 @@ class Monster extends Table
         self::addNativeInline($builder, $native_inline);
         self::addLongEnumNonEnumDefault($builder, $long_enum_non_enum_default);
         self::addLongEnumNormalDefault($builder, $long_enum_normal_default);
+        self::addNanDefault($builder, $nan_default);
+        self::addInfDefault($builder, $inf_default);
+        self::addPositiveInfDefault($builder, $positive_inf_default);
+        self::addInfinityDefault($builder, $infinity_default);
+        self::addPositiveInfinityDefault($builder, $positive_infinity_default);
+        self::addNegativeInfDefault($builder, $negative_inf_default);
+        self::addNegativeInfinityDefault($builder, $negative_infinity_default);
+        self::addDoubleInfDefault($builder, $double_inf_default);
         $o = $builder->endObject();
         $builder->required($o, 10);  // name
         return $o;
@@ -1823,6 +1903,86 @@ class Monster extends Table
         $builder->addUlongX(53, $longEnumNormalDefault, 2);
     }
 
+    /**
+     * @param FlatBufferBuilder $builder
+     * @param float
+     * @return void
+     */
+    public static function addNanDefault(FlatBufferBuilder $builder, $nanDefault)
+    {
+        $builder->addFloatX(54, $nanDefault, nan);
+    }
+
+    /**
+     * @param FlatBufferBuilder $builder
+     * @param float
+     * @return void
+     */
+    public static function addInfDefault(FlatBufferBuilder $builder, $infDefault)
+    {
+        $builder->addFloatX(55, $infDefault, inf);
+    }
+
+    /**
+     * @param FlatBufferBuilder $builder
+     * @param float
+     * @return void
+     */
+    public static function addPositiveInfDefault(FlatBufferBuilder $builder, $positiveInfDefault)
+    {
+        $builder->addFloatX(56, $positiveInfDefault, +inf);
+    }
+
+    /**
+     * @param FlatBufferBuilder $builder
+     * @param float
+     * @return void
+     */
+    public static function addInfinityDefault(FlatBufferBuilder $builder, $infinityDefault)
+    {
+        $builder->addFloatX(57, $infinityDefault, infinity);
+    }
+
+    /**
+     * @param FlatBufferBuilder $builder
+     * @param float
+     * @return void
+     */
+    public static function addPositiveInfinityDefault(FlatBufferBuilder $builder, $positiveInfinityDefault)
+    {
+        $builder->addFloatX(58, $positiveInfinityDefault, +infinity);
+    }
+
+    /**
+     * @param FlatBufferBuilder $builder
+     * @param float
+     * @return void
+     */
+    public static function addNegativeInfDefault(FlatBufferBuilder $builder, $negativeInfDefault)
+    {
+        $builder->addFloatX(59, $negativeInfDefault, -inf);
+    }
+
+    /**
+     * @param FlatBufferBuilder $builder
+     * @param float
+     * @return void
+     */
+    public static function addNegativeInfinityDefault(FlatBufferBuilder $builder, $negativeInfinityDefault)
+    {
+        $builder->addFloatX(60, $negativeInfinityDefault, -infinity);
+    }
+
+    /**
+     * @param FlatBufferBuilder $builder
+     * @param double
+     * @return void
+     */
+    public static function addDoubleInfDefault(FlatBufferBuilder $builder, $doubleInfDefault)
+    {
+        $builder->addDoubleX(61, $doubleInfDefault, inf);
+    }
+
     /**
      * @param FlatBufferBuilder $builder
      * @return int table offset

tests/MyGame/Example/Monster.py

@@ -816,7 +816,63 @@ class Monster(object):
             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
         return 2
 
-def MonsterStart(builder): builder.StartObject(54)
+    # Monster
+    def NanDefault(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(112))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return float('nan')
+
+    # Monster
+    def InfDefault(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(114))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return float('inf')
+
+    # Monster
+    def PositiveInfDefault(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(116))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return float('inf')
+
+    # Monster
+    def InfinityDefault(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(118))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return float('inf')
+
+    # Monster
+    def PositiveInfinityDefault(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(120))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return float('inf')
+
+    # Monster
+    def NegativeInfDefault(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(122))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return float('-inf')
+
+    # Monster
+    def NegativeInfinityDefault(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(124))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return float('-inf')
+
+    # Monster
+    def DoubleInfDefault(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(126))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return float('inf')
+
+def MonsterStart(builder): builder.StartObject(62)
 def Start(builder):
     return MonsterStart(builder)
 def MonsterAddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
@@ -1052,6 +1108,30 @@ def AddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault):
 def MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault): builder.PrependUint64Slot(53, longEnumNormalDefault, 2)
 def AddLongEnumNormalDefault(builder, longEnumNormalDefault):
     return MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault)
+def MonsterAddNanDefault(builder, nanDefault): builder.PrependFloat32Slot(54, nanDefault, float('nan'))
+def AddNanDefault(builder, nanDefault):
+    return MonsterAddNanDefault(builder, nanDefault)
+def MonsterAddInfDefault(builder, infDefault): builder.PrependFloat32Slot(55, infDefault, float('inf'))
+def AddInfDefault(builder, infDefault):
+    return MonsterAddInfDefault(builder, infDefault)
+def MonsterAddPositiveInfDefault(builder, positiveInfDefault): builder.PrependFloat32Slot(56, positiveInfDefault, float('inf'))
+def AddPositiveInfDefault(builder, positiveInfDefault):
+    return MonsterAddPositiveInfDefault(builder, positiveInfDefault)
+def MonsterAddInfinityDefault(builder, infinityDefault): builder.PrependFloat32Slot(57, infinityDefault, float('inf'))
+def AddInfinityDefault(builder, infinityDefault):
+    return MonsterAddInfinityDefault(builder, infinityDefault)
+def MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault): builder.PrependFloat32Slot(58, positiveInfinityDefault, float('inf'))
+def AddPositiveInfinityDefault(builder, positiveInfinityDefault):
+    return MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault)
+def MonsterAddNegativeInfDefault(builder, negativeInfDefault): builder.PrependFloat32Slot(59, negativeInfDefault, float('-inf'))
+def AddNegativeInfDefault(builder, negativeInfDefault):
+    return MonsterAddNegativeInfDefault(builder, negativeInfDefault)
+def MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault): builder.PrependFloat32Slot(60, negativeInfinityDefault, float('-inf'))
+def AddNegativeInfinityDefault(builder, negativeInfinityDefault):
+    return MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault)
+def MonsterAddDoubleInfDefault(builder, doubleInfDefault): builder.PrependFloat64Slot(61, doubleInfDefault, float('inf'))
+def AddDoubleInfDefault(builder, doubleInfDefault):
+    return MonsterAddDoubleInfDefault(builder, doubleInfDefault)
 def MonsterEnd(builder): return builder.EndObject()
 def End(builder):
     return MonsterEnd(builder)
@@ -1128,6 +1208,14 @@ class MonsterT(object):
         self.nativeInline = None  # type: Optional[MyGame.Example.Test.TestT]
         self.longEnumNonEnumDefault = 0  # type: int
         self.longEnumNormalDefault = 2  # type: int
+        self.nanDefault = float('nan')  # type: float
+        self.infDefault = float('inf')  # type: float
+        self.positiveInfDefault = float('inf')  # type: float
+        self.infinityDefault = float('inf')  # type: float
+        self.positiveInfinityDefault = float('inf')  # type: float
+        self.negativeInfDefault = float('-inf')  # type: float
+        self.negativeInfinityDefault = float('-inf')  # type: float
+        self.doubleInfDefault = float('inf')  # type: float
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
@@ -1329,6 +1417,14 @@ class MonsterT(object):
             self.nativeInline = MyGame.Example.Test.TestT.InitFromObj(monster.NativeInline())
         self.longEnumNonEnumDefault = monster.LongEnumNonEnumDefault()
         self.longEnumNormalDefault = monster.LongEnumNormalDefault()
+        self.nanDefault = monster.NanDefault()
+        self.infDefault = monster.InfDefault()
+        self.positiveInfDefault = monster.PositiveInfDefault()
+        self.infinityDefault = monster.InfinityDefault()
+        self.positiveInfinityDefault = monster.PositiveInfinityDefault()
+        self.negativeInfDefault = monster.NegativeInfDefault()
+        self.negativeInfinityDefault = monster.NegativeInfinityDefault()
+        self.doubleInfDefault = monster.DoubleInfDefault()
 
     # MonsterT
     def Pack(self, builder):
@@ -1582,5 +1678,13 @@ class MonsterT(object):
             MonsterAddNativeInline(builder, nativeInline)
         MonsterAddLongEnumNonEnumDefault(builder, self.longEnumNonEnumDefault)
         MonsterAddLongEnumNormalDefault(builder, self.longEnumNormalDefault)
+        MonsterAddNanDefault(builder, self.nanDefault)
+        MonsterAddInfDefault(builder, self.infDefault)
+        MonsterAddPositiveInfDefault(builder, self.positiveInfDefault)
+        MonsterAddInfinityDefault(builder, self.infinityDefault)
+        MonsterAddPositiveInfinityDefault(builder, self.positiveInfinityDefault)
+        MonsterAddNegativeInfDefault(builder, self.negativeInfDefault)
+        MonsterAddNegativeInfinityDefault(builder, self.negativeInfinityDefault)
+        MonsterAddDoubleInfDefault(builder, self.doubleInfDefault)
         monster = MonsterEnd(builder)
         return monster

tests/MyGame/Example/MonsterT.java

@@ -58,6 +58,14 @@ public class MonsterT {
   private MyGame.Example.TestT nativeInline;
   private long longEnumNonEnumDefault;
   private long longEnumNormalDefault;
+  private float nanDefault;
+  private float infDefault;
+  private float positiveInfDefault;
+  private float infinityDefault;
+  private float positiveInfinityDefault;
+  private float negativeInfDefault;
+  private float negativeInfinityDefault;
+  private double doubleInfDefault;
 
   public MyGame.Example.Vec3T getPos() { return pos; }
 
@@ -259,6 +267,38 @@ public class MonsterT {
 
   public void setLongEnumNormalDefault(long longEnumNormalDefault) { this.longEnumNormalDefault = longEnumNormalDefault; }
 
+  public float getNanDefault() { return nanDefault; }
+
+  public void setNanDefault(float nanDefault) { this.nanDefault = nanDefault; }
+
+  public float getInfDefault() { return infDefault; }
+
+  public void setInfDefault(float infDefault) { this.infDefault = infDefault; }
+
+  public float getPositiveInfDefault() { return positiveInfDefault; }
+
+  public void setPositiveInfDefault(float positiveInfDefault) { this.positiveInfDefault = positiveInfDefault; }
+
+  public float getInfinityDefault() { return infinityDefault; }
+
+  public void setInfinityDefault(float infinityDefault) { this.infinityDefault = infinityDefault; }
+
+  public float getPositiveInfinityDefault() { return positiveInfinityDefault; }
+
+  public void setPositiveInfinityDefault(float positiveInfinityDefault) { this.positiveInfinityDefault = positiveInfinityDefault; }
+
+  public float getNegativeInfDefault() { return negativeInfDefault; }
+
+  public void setNegativeInfDefault(float negativeInfDefault) { this.negativeInfDefault = negativeInfDefault; }
+
+  public float getNegativeInfinityDefault() { return negativeInfinityDefault; }
+
+  public void setNegativeInfinityDefault(float negativeInfinityDefault) { this.negativeInfinityDefault = negativeInfinityDefault; }
+
+  public double getDoubleInfDefault() { return doubleInfDefault; }
+
+  public void setDoubleInfDefault(double doubleInfDefault) { this.doubleInfDefault = doubleInfDefault; }
+
 
   public MonsterT() {
     this.pos = new MyGame.Example.Vec3T();
@@ -311,6 +351,14 @@ public class MonsterT {
     this.nativeInline = new MyGame.Example.TestT();
     this.longEnumNonEnumDefault = 0L;
     this.longEnumNormalDefault = 2L;
+    this.nanDefault = Float.NaN;
+    this.infDefault = Float.POSITIVE_INFINITY;
+    this.positiveInfDefault = Float.POSITIVE_INFINITY;
+    this.infinityDefault = Float.POSITIVE_INFINITY;
+    this.positiveInfinityDefault = Float.POSITIVE_INFINITY;
+    this.negativeInfDefault = Float.NEGATIVE_INFINITY;
+    this.negativeInfinityDefault = Float.NEGATIVE_INFINITY;
+    this.doubleInfDefault = Double.POSITIVE_INFINITY;
   }
   public static MonsterT deserializeFromBinary(byte[] fbBuffer) {
     return Monster.getRootAsMonster(ByteBuffer.wrap(fbBuffer)).unpack();

tests/cpp17/generated_cpp17/monster_test_generated.h

@@ -1321,6 +1321,14 @@ struct MonsterT : public flatbuffers::NativeTable {
   MyGame::Example::Test native_inline{};
   MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0);
   MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum::LongOne;
+  float nan_default = std::numeric_limits<float>::quiet_NaN();
+  float inf_default = std::numeric_limits<float>::infinity();
+  float positive_inf_default = std::numeric_limits<float>::infinity();
+  float infinity_default = std::numeric_limits<float>::infinity();
+  float positive_infinity_default = std::numeric_limits<float>::infinity();
+  float negative_inf_default = -std::numeric_limits<float>::infinity();
+  float negative_infinity_default = -std::numeric_limits<float>::infinity();
+  double double_inf_default = std::numeric_limits<double>::infinity();
   MonsterT() = default;
   MonsterT(const MonsterT &o);
   MonsterT(MonsterT&&) FLATBUFFERS_NOEXCEPT = default;
@@ -1388,7 +1396,15 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_SCALAR_KEY_SORTED_TABLES = 104,
     VT_NATIVE_INLINE = 106,
     VT_LONG_ENUM_NON_ENUM_DEFAULT = 108,
-    VT_LONG_ENUM_NORMAL_DEFAULT = 110
+    VT_LONG_ENUM_NORMAL_DEFAULT = 110,
+    VT_NAN_DEFAULT = 112,
+    VT_INF_DEFAULT = 114,
+    VT_POSITIVE_INF_DEFAULT = 116,
+    VT_INFINITY_DEFAULT = 118,
+    VT_POSITIVE_INFINITY_DEFAULT = 120,
+    VT_NEGATIVE_INF_DEFAULT = 122,
+    VT_NEGATIVE_INFINITY_DEFAULT = 124,
+    VT_DOUBLE_INF_DEFAULT = 126
   };
   const MyGame::Example::Vec3 *pos() const {
     return GetStruct<const MyGame::Example::Vec3 *>(VT_POS);
@@ -1745,6 +1761,54 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   bool mutate_long_enum_normal_default(MyGame::Example::LongEnum _long_enum_normal_default = static_cast<MyGame::Example::LongEnum>(2ULL)) {
     return SetField<uint64_t>(VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(_long_enum_normal_default), 2ULL);
   }
+  float nan_default() const {
+    return GetField<float>(VT_NAN_DEFAULT, std::numeric_limits<float>::quiet_NaN());
+  }
+  bool mutate_nan_default(float _nan_default = std::numeric_limits<float>::quiet_NaN()) {
+    return SetField<float>(VT_NAN_DEFAULT, _nan_default, std::numeric_limits<float>::quiet_NaN());
+  }
+  float inf_default() const {
+    return GetField<float>(VT_INF_DEFAULT, std::numeric_limits<float>::infinity());
+  }
+  bool mutate_inf_default(float _inf_default = std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_INF_DEFAULT, _inf_default, std::numeric_limits<float>::infinity());
+  }
+  float positive_inf_default() const {
+    return GetField<float>(VT_POSITIVE_INF_DEFAULT, std::numeric_limits<float>::infinity());
+  }
+  bool mutate_positive_inf_default(float _positive_inf_default = std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_POSITIVE_INF_DEFAULT, _positive_inf_default, std::numeric_limits<float>::infinity());
+  }
+  float infinity_default() const {
+    return GetField<float>(VT_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
+  }
+  bool mutate_infinity_default(float _infinity_default = std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_INFINITY_DEFAULT, _infinity_default, std::numeric_limits<float>::infinity());
+  }
+  float positive_infinity_default() const {
+    return GetField<float>(VT_POSITIVE_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
+  }
+  bool mutate_positive_infinity_default(float _positive_infinity_default = std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_POSITIVE_INFINITY_DEFAULT, _positive_infinity_default, std::numeric_limits<float>::infinity());
+  }
+  float negative_inf_default() const {
+    return GetField<float>(VT_NEGATIVE_INF_DEFAULT, -std::numeric_limits<float>::infinity());
+  }
+  bool mutate_negative_inf_default(float _negative_inf_default = -std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_NEGATIVE_INF_DEFAULT, _negative_inf_default, -std::numeric_limits<float>::infinity());
+  }
+  float negative_infinity_default() const {
+    return GetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, -std::numeric_limits<float>::infinity());
+  }
+  bool mutate_negative_infinity_default(float _negative_infinity_default = -std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, _negative_infinity_default, -std::numeric_limits<float>::infinity());
+  }
+  double double_inf_default() const {
+    return GetField<double>(VT_DOUBLE_INF_DEFAULT, std::numeric_limits<double>::infinity());
+  }
+  bool mutate_double_inf_default(double _double_inf_default = std::numeric_limits<double>::infinity()) {
+    return SetField<double>(VT_DOUBLE_INF_DEFAULT, _double_inf_default, std::numeric_limits<double>::infinity());
+  }
   template<size_t Index>
   auto get_field() const {
          if constexpr (Index == 0) return pos();
@@ -1800,6 +1864,14 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     else if constexpr (Index == 50) return native_inline();
     else if constexpr (Index == 51) return long_enum_non_enum_default();
     else if constexpr (Index == 52) return long_enum_normal_default();
+    else if constexpr (Index == 53) return nan_default();
+    else if constexpr (Index == 54) return inf_default();
+    else if constexpr (Index == 55) return positive_inf_default();
+    else if constexpr (Index == 56) return infinity_default();
+    else if constexpr (Index == 57) return positive_infinity_default();
+    else if constexpr (Index == 58) return negative_inf_default();
+    else if constexpr (Index == 59) return negative_infinity_default();
+    else if constexpr (Index == 60) return double_inf_default();
     else static_assert(Index != Index, "Invalid Field Index");
   }
   bool Verify(flatbuffers::Verifier &verifier) const {
@@ -1893,6 +1965,14 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
            VerifyField<MyGame::Example::Test>(verifier, VT_NATIVE_INLINE, 2) &&
            VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NON_ENUM_DEFAULT, 8) &&
            VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NORMAL_DEFAULT, 8) &&
+           VerifyField<float>(verifier, VT_NAN_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_INF_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_POSITIVE_INF_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_INFINITY_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_POSITIVE_INFINITY_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_NEGATIVE_INF_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_NEGATIVE_INFINITY_DEFAULT, 4) &&
+           VerifyField<double>(verifier, VT_DOUBLE_INF_DEFAULT, 8) &&
            verifier.EndTable();
   }
   MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -2087,6 +2167,30 @@ struct MonsterBuilder {
   void add_long_enum_normal_default(MyGame::Example::LongEnum long_enum_normal_default) {
     fbb_.AddElement<uint64_t>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(long_enum_normal_default), 2ULL);
   }
+  void add_nan_default(float nan_default) {
+    fbb_.AddElement<float>(Monster::VT_NAN_DEFAULT, nan_default, std::numeric_limits<float>::quiet_NaN());
+  }
+  void add_inf_default(float inf_default) {
+    fbb_.AddElement<float>(Monster::VT_INF_DEFAULT, inf_default, std::numeric_limits<float>::infinity());
+  }
+  void add_positive_inf_default(float positive_inf_default) {
+    fbb_.AddElement<float>(Monster::VT_POSITIVE_INF_DEFAULT, positive_inf_default, std::numeric_limits<float>::infinity());
+  }
+  void add_infinity_default(float infinity_default) {
+    fbb_.AddElement<float>(Monster::VT_INFINITY_DEFAULT, infinity_default, std::numeric_limits<float>::infinity());
+  }
+  void add_positive_infinity_default(float positive_infinity_default) {
+    fbb_.AddElement<float>(Monster::VT_POSITIVE_INFINITY_DEFAULT, positive_infinity_default, std::numeric_limits<float>::infinity());
+  }
+  void add_negative_inf_default(float negative_inf_default) {
+    fbb_.AddElement<float>(Monster::VT_NEGATIVE_INF_DEFAULT, negative_inf_default, -std::numeric_limits<float>::infinity());
+  }
+  void add_negative_infinity_default(float negative_infinity_default) {
+    fbb_.AddElement<float>(Monster::VT_NEGATIVE_INFINITY_DEFAULT, negative_infinity_default, -std::numeric_limits<float>::infinity());
+  }
+  void add_double_inf_default(double double_inf_default) {
+    fbb_.AddElement<double>(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, std::numeric_limits<double>::infinity());
+  }
   explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -2153,8 +2257,17 @@ inline flatbuffers::Offset<Monster> CreateMonster(
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables = 0,
     const MyGame::Example::Test *native_inline = nullptr,
     MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
-    MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum::LongOne) {
+    MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum::LongOne,
+    float nan_default = std::numeric_limits<float>::quiet_NaN(),
+    float inf_default = std::numeric_limits<float>::infinity(),
+    float positive_inf_default = std::numeric_limits<float>::infinity(),
+    float infinity_default = std::numeric_limits<float>::infinity(),
+    float positive_infinity_default = std::numeric_limits<float>::infinity(),
+    float negative_inf_default = -std::numeric_limits<float>::infinity(),
+    float negative_infinity_default = -std::numeric_limits<float>::infinity(),
+    double double_inf_default = std::numeric_limits<double>::infinity()) {
   MonsterBuilder builder_(_fbb);
+  builder_.add_double_inf_default(double_inf_default);
   builder_.add_long_enum_normal_default(long_enum_normal_default);
   builder_.add_long_enum_non_enum_default(long_enum_non_enum_default);
   builder_.add_non_owning_reference(non_owning_reference);
@@ -2164,6 +2277,13 @@ inline flatbuffers::Offset<Monster> CreateMonster(
   builder_.add_testhashs64_fnv1a(testhashs64_fnv1a);
   builder_.add_testhashu64_fnv1(testhashu64_fnv1);
   builder_.add_testhashs64_fnv1(testhashs64_fnv1);
+  builder_.add_negative_infinity_default(negative_infinity_default);
+  builder_.add_negative_inf_default(negative_inf_default);
+  builder_.add_positive_infinity_default(positive_infinity_default);
+  builder_.add_infinity_default(infinity_default);
+  builder_.add_positive_inf_default(positive_inf_default);
+  builder_.add_inf_default(inf_default);
+  builder_.add_nan_default(nan_default);
   builder_.add_native_inline(native_inline);
   builder_.add_scalar_key_sorted_tables(scalar_key_sorted_tables);
   builder_.add_testrequirednestedflatbuffer(testrequirednestedflatbuffer);
@@ -2216,7 +2336,7 @@ struct Monster::Traits {
   static auto constexpr Create = CreateMonster;
   static constexpr auto name = "Monster";
   static constexpr auto fully_qualified_name = "MyGame.Example.Monster";
-  static constexpr size_t fields_number = 53;
+  static constexpr size_t fields_number = 61;
   static constexpr std::array<const char *, fields_number> field_names = {
     "pos",
     "mana",
@@ -2270,7 +2390,15 @@ struct Monster::Traits {
     "scalar_key_sorted_tables",
     "native_inline",
     "long_enum_non_enum_default",
-    "long_enum_normal_default"
+    "long_enum_normal_default",
+    "nan_default",
+    "inf_default",
+    "positive_inf_default",
+    "infinity_default",
+    "positive_infinity_default",
+    "negative_inf_default",
+    "negative_infinity_default",
+    "double_inf_default"
   };
   template<size_t Index>
   using FieldType = decltype(std::declval<type>().get_field<Index>());
@@ -2330,7 +2458,15 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
     std::vector<flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables = nullptr,
     const MyGame::Example::Test *native_inline = nullptr,
     MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
-    MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum::LongOne) {
+    MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum::LongOne,
+    float nan_default = std::numeric_limits<float>::quiet_NaN(),
+    float inf_default = std::numeric_limits<float>::infinity(),
+    float positive_inf_default = std::numeric_limits<float>::infinity(),
+    float infinity_default = std::numeric_limits<float>::infinity(),
+    float positive_infinity_default = std::numeric_limits<float>::infinity(),
+    float negative_inf_default = -std::numeric_limits<float>::infinity(),
+    float negative_infinity_default = -std::numeric_limits<float>::infinity(),
+    double double_inf_default = std::numeric_limits<double>::infinity()) {
   auto name__ = name ? _fbb.CreateString(name) : 0;
   auto inventory__ = inventory ? _fbb.CreateVector<uint8_t>(*inventory) : 0;
   auto test4__ = test4 ? _fbb.CreateVectorOfStructs<MyGame::Example::Test>(*test4) : 0;
@@ -2406,7 +2542,15 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
       scalar_key_sorted_tables__,
       native_inline,
       long_enum_non_enum_default,
-      long_enum_normal_default);
+      long_enum_normal_default,
+      nan_default,
+      inf_default,
+      positive_inf_default,
+      infinity_default,
+      positive_infinity_default,
+      negative_inf_default,
+      negative_infinity_default,
+      double_inf_default);
 }
 
 flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -2881,7 +3025,15 @@ inline MonsterT::MonsterT(const MonsterT &o)
         testrequirednestedflatbuffer(o.testrequirednestedflatbuffer),
         native_inline(o.native_inline),
         long_enum_non_enum_default(o.long_enum_non_enum_default),
-        long_enum_normal_default(o.long_enum_normal_default) {
+        long_enum_normal_default(o.long_enum_normal_default),
+        nan_default(o.nan_default),
+        inf_default(o.inf_default),
+        positive_inf_default(o.positive_inf_default),
+        infinity_default(o.infinity_default),
+        positive_infinity_default(o.positive_infinity_default),
+        negative_inf_default(o.negative_inf_default),
+        negative_infinity_default(o.negative_infinity_default),
+        double_inf_default(o.double_inf_default) {
   testarrayoftables.reserve(o.testarrayoftables.size());
   for (const auto &testarrayoftables_ : o.testarrayoftables) { testarrayoftables.emplace_back((testarrayoftables_) ? new MyGame::Example::MonsterT(*testarrayoftables_) : nullptr); }
   vector_of_referrables.reserve(o.vector_of_referrables.size());
@@ -2945,6 +3097,14 @@ inline MonsterT &MonsterT::operator=(MonsterT o) FLATBUFFERS_NOEXCEPT {
   std::swap(native_inline, o.native_inline);
   std::swap(long_enum_non_enum_default, o.long_enum_non_enum_default);
   std::swap(long_enum_normal_default, o.long_enum_normal_default);
+  std::swap(nan_default, o.nan_default);
+  std::swap(inf_default, o.inf_default);
+  std::swap(positive_inf_default, o.positive_inf_default);
+  std::swap(infinity_default, o.infinity_default);
+  std::swap(positive_infinity_default, o.positive_infinity_default);
+  std::swap(negative_inf_default, o.negative_inf_default);
+  std::swap(negative_infinity_default, o.negative_infinity_default);
+  std::swap(double_inf_default, o.double_inf_default);
   return *this;
 }
 
@@ -3010,6 +3170,14 @@ inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function
   { auto _e = native_inline(); if (_e) _o->native_inline = *_e; }
   { auto _e = long_enum_non_enum_default(); _o->long_enum_non_enum_default = _e; }
   { auto _e = long_enum_normal_default(); _o->long_enum_normal_default = _e; }
+  { auto _e = nan_default(); _o->nan_default = _e; }
+  { auto _e = inf_default(); _o->inf_default = _e; }
+  { auto _e = positive_inf_default(); _o->positive_inf_default = _e; }
+  { auto _e = infinity_default(); _o->infinity_default = _e; }
+  { auto _e = positive_infinity_default(); _o->positive_infinity_default = _e; }
+  { auto _e = negative_inf_default(); _o->negative_inf_default = _e; }
+  { auto _e = negative_infinity_default(); _o->negative_infinity_default = _e; }
+  { auto _e = double_inf_default(); _o->double_inf_default = _e; }
 }
 
 inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -3073,6 +3241,14 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
   auto _native_inline = &_o->native_inline;
   auto _long_enum_non_enum_default = _o->long_enum_non_enum_default;
   auto _long_enum_normal_default = _o->long_enum_normal_default;
+  auto _nan_default = _o->nan_default;
+  auto _inf_default = _o->inf_default;
+  auto _positive_inf_default = _o->positive_inf_default;
+  auto _infinity_default = _o->infinity_default;
+  auto _positive_infinity_default = _o->positive_infinity_default;
+  auto _negative_inf_default = _o->negative_inf_default;
+  auto _negative_infinity_default = _o->negative_infinity_default;
+  auto _double_inf_default = _o->double_inf_default;
   return MyGame::Example::CreateMonster(
       _fbb,
       _pos,
@@ -3127,7 +3303,15 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
       _scalar_key_sorted_tables,
       _native_inline,
       _long_enum_non_enum_default,
-      _long_enum_normal_default);
+      _long_enum_normal_default,
+      _nan_default,
+      _inf_default,
+      _positive_inf_default,
+      _infinity_default,
+      _positive_infinity_default,
+      _negative_inf_default,
+      _negative_infinity_default,
+      _double_inf_default);
 }
 
 inline TypeAliasesT *TypeAliases::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
@@ -3885,7 +4069,15 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
     { flatbuffers::ET_SEQUENCE, 1, 5 },
     { flatbuffers::ET_SEQUENCE, 0, 3 },
     { flatbuffers::ET_ULONG, 0, 12 },
-    { flatbuffers::ET_ULONG, 0, 12 }
+    { flatbuffers::ET_ULONG, 0, 12 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_DOUBLE, 0, -1 }
   };
   static const flatbuffers::TypeFunction type_refs[] = {
     MyGame::Example::Vec3TypeTable,
@@ -3956,10 +4148,18 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
     "scalar_key_sorted_tables",
     "native_inline",
     "long_enum_non_enum_default",
-    "long_enum_normal_default"
+    "long_enum_normal_default",
+    "nan_default",
+    "inf_default",
+    "positive_inf_default",
+    "infinity_default",
+    "positive_infinity_default",
+    "negative_inf_default",
+    "negative_infinity_default",
+    "double_inf_default"
   };
   static const flatbuffers::TypeTable tt = {
-    flatbuffers::ST_TABLE, 54, type_codes, type_refs, nullptr, nullptr, names
+    flatbuffers::ST_TABLE, 62, type_codes, type_refs, nullptr, nullptr, names
   };
   return &tt;
 }

tests/cpp17/test_cpp17.cpp

@@ -148,6 +148,14 @@ void StringifyAnyFlatbuffersTypeTest() {
         signed_enum = -1
         long_enum_non_enum_default = 0
         long_enum_normal_default = 2
+        nan_default = nan
+        inf_default = inf
+        positive_inf_default = inf
+        infinity_default = inf
+        positive_infinity_default = inf
+        negative_inf_default = -inf
+        negative_infinity_default = -inf
+        double_inf_default = inf
       })";
 
   // Call a generic function that has no specific knowledge of the flatbuffer we

tests/go_test.go

@@ -533,6 +533,14 @@ func CheckObjectAPI(buf []byte, offset flatbuffers.UOffsetT, sizePrefix bool, fa
 		fail(FailString("mana", 150, got))
 	}
 
+	if monster.Test != nil && monster.Test.Type == example.AnyMonster {
+		monster.Test.Value.(*example.MonsterT).NanDefault = 0.0
+	}
+	if monster.Enemy != nil {
+		monster.Enemy.NanDefault = 0.0
+	}
+	monster.NanDefault = 0.0
+
 	builder := flatbuffers.NewBuilder(0)
 	builder.Finish(monster.Pack(builder))
 	monster2 := example.GetRootAsMonster(builder.FinishedBytes(), 0).UnPack()

tests/monster_test.fbs

@@ -141,6 +141,15 @@ table Monster {
   // enum value.
   long_enum_non_enum_default:LongEnum (id: 52);
   long_enum_normal_default:LongEnum = LongOne (id: 53);
+  // Test that default values nan and +/-inf work.
+  nan_default:float = nan (id: 54);
+  inf_default:float = inf (id: 55);
+  positive_inf_default:float = +inf (id: 56);
+  infinity_default:float = infinity (id: 57);
+  positive_infinity_default:float = +infinity (id: 58);
+  negative_inf_default:float = -inf (id: 59);
+  negative_infinity_default:float = -infinity (id: 60);
+  double_inf_default:double = inf (id: 61);
 }
 
 table TypeAliases {

tests/monster_test.schema.json

@@ -340,6 +340,30 @@
               },
         "long_enum_normal_default" : {
                 "$ref" : "#/definitions/MyGame_Example_LongEnum"
+              },
+        "nan_default" : {
+                "type" : "number"
+              },
+        "inf_default" : {
+                "type" : "number"
+              },
+        "positive_inf_default" : {
+                "type" : "number"
+              },
+        "infinity_default" : {
+                "type" : "number"
+              },
+        "positive_infinity_default" : {
+                "type" : "number"
+              },
+        "negative_inf_default" : {
+                "type" : "number"
+              },
+        "negative_infinity_default" : {
+                "type" : "number"
+              },
+        "double_inf_default" : {
+                "type" : "number"
               }
       },
       "required" : ["name"],

tests/monster_test/my_game/example/monster_generated.rs

@@ -79,6 +79,14 @@ impl<'a> Monster<'a> {
   pub const VT_NATIVE_INLINE: flatbuffers::VOffsetT = 106;
   pub const VT_LONG_ENUM_NON_ENUM_DEFAULT: flatbuffers::VOffsetT = 108;
   pub const VT_LONG_ENUM_NORMAL_DEFAULT: flatbuffers::VOffsetT = 110;
+  pub const VT_NAN_DEFAULT: flatbuffers::VOffsetT = 112;
+  pub const VT_INF_DEFAULT: flatbuffers::VOffsetT = 114;
+  pub const VT_POSITIVE_INF_DEFAULT: flatbuffers::VOffsetT = 116;
+  pub const VT_INFINITY_DEFAULT: flatbuffers::VOffsetT = 118;
+  pub const VT_POSITIVE_INFINITY_DEFAULT: flatbuffers::VOffsetT = 120;
+  pub const VT_NEGATIVE_INF_DEFAULT: flatbuffers::VOffsetT = 122;
+  pub const VT_NEGATIVE_INFINITY_DEFAULT: flatbuffers::VOffsetT = 124;
+  pub const VT_DOUBLE_INF_DEFAULT: flatbuffers::VOffsetT = 126;
 
   pub const fn get_fully_qualified_name() -> &'static str {
     "MyGame.Example.Monster"
@@ -94,6 +102,7 @@ impl<'a> Monster<'a> {
     args: &'args MonsterArgs<'args>
   ) -> flatbuffers::WIPOffset<Monster<'bldr>> {
     let mut builder = MonsterBuilder::new(_fbb);
+    builder.add_double_inf_default(args.double_inf_default);
     builder.add_long_enum_normal_default(args.long_enum_normal_default);
     builder.add_long_enum_non_enum_default(args.long_enum_non_enum_default);
     builder.add_non_owning_reference(args.non_owning_reference);
@@ -103,6 +112,13 @@ impl<'a> Monster<'a> {
     builder.add_testhashs64_fnv1a(args.testhashs64_fnv1a);
     builder.add_testhashu64_fnv1(args.testhashu64_fnv1);
     builder.add_testhashs64_fnv1(args.testhashs64_fnv1);
+    builder.add_negative_infinity_default(args.negative_infinity_default);
+    builder.add_negative_inf_default(args.negative_inf_default);
+    builder.add_positive_infinity_default(args.positive_infinity_default);
+    builder.add_infinity_default(args.infinity_default);
+    builder.add_positive_inf_default(args.positive_inf_default);
+    builder.add_inf_default(args.inf_default);
+    builder.add_nan_default(args.nan_default);
     if let Some(x) = args.native_inline { builder.add_native_inline(x); }
     if let Some(x) = args.scalar_key_sorted_tables { builder.add_scalar_key_sorted_tables(x); }
     if let Some(x) = args.testrequirednestedflatbuffer { builder.add_testrequirednestedflatbuffer(x); }
@@ -308,6 +324,14 @@ impl<'a> Monster<'a> {
     });
     let long_enum_non_enum_default = self.long_enum_non_enum_default();
     let long_enum_normal_default = self.long_enum_normal_default();
+    let nan_default = self.nan_default();
+    let inf_default = self.inf_default();
+    let positive_inf_default = self.positive_inf_default();
+    let infinity_default = self.infinity_default();
+    let positive_infinity_default = self.positive_infinity_default();
+    let negative_inf_default = self.negative_inf_default();
+    let negative_infinity_default = self.negative_infinity_default();
+    let double_inf_default = self.double_inf_default();
     MonsterT {
       pos,
       mana,
@@ -359,6 +383,14 @@ impl<'a> Monster<'a> {
       native_inline,
       long_enum_non_enum_default,
       long_enum_normal_default,
+      nan_default,
+      inf_default,
+      positive_inf_default,
+      infinity_default,
+      positive_infinity_default,
+      negative_inf_default,
+      negative_infinity_default,
+      double_inf_default,
     }
   }
 
@@ -764,6 +796,62 @@ impl<'a> Monster<'a> {
     unsafe { self._tab.get::<LongEnum>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, Some(LongEnum::LongOne)).unwrap()}
   }
   #[inline]
+  pub fn nan_default(&self) -> f32 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f32>(Monster::VT_NAN_DEFAULT, Some(f32::NAN)).unwrap()}
+  }
+  #[inline]
+  pub fn inf_default(&self) -> f32 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f32>(Monster::VT_INF_DEFAULT, Some(f32::INFINITY)).unwrap()}
+  }
+  #[inline]
+  pub fn positive_inf_default(&self) -> f32 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f32>(Monster::VT_POSITIVE_INF_DEFAULT, Some(f32::INFINITY)).unwrap()}
+  }
+  #[inline]
+  pub fn infinity_default(&self) -> f32 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f32>(Monster::VT_INFINITY_DEFAULT, Some(f32::INFINITY)).unwrap()}
+  }
+  #[inline]
+  pub fn positive_infinity_default(&self) -> f32 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f32>(Monster::VT_POSITIVE_INFINITY_DEFAULT, Some(f32::INFINITY)).unwrap()}
+  }
+  #[inline]
+  pub fn negative_inf_default(&self) -> f32 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f32>(Monster::VT_NEGATIVE_INF_DEFAULT, Some(f32::NEG_INFINITY)).unwrap()}
+  }
+  #[inline]
+  pub fn negative_infinity_default(&self) -> f32 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f32>(Monster::VT_NEGATIVE_INFINITY_DEFAULT, Some(f32::NEG_INFINITY)).unwrap()}
+  }
+  #[inline]
+  pub fn double_inf_default(&self) -> f64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f64>(Monster::VT_DOUBLE_INF_DEFAULT, Some(f64::INFINITY)).unwrap()}
+  }
+  #[inline]
   #[allow(non_snake_case)]
   pub fn test_as_monster(&self) -> Option<Monster<'a>> {
     if self.test_type() == Any::Monster {
@@ -978,6 +1066,14 @@ impl flatbuffers::Verifiable for Monster<'_> {
      .visit_field::<Test>("native_inline", Self::VT_NATIVE_INLINE, false)?
      .visit_field::<LongEnum>("long_enum_non_enum_default", Self::VT_LONG_ENUM_NON_ENUM_DEFAULT, false)?
      .visit_field::<LongEnum>("long_enum_normal_default", Self::VT_LONG_ENUM_NORMAL_DEFAULT, false)?
+     .visit_field::<f32>("nan_default", Self::VT_NAN_DEFAULT, false)?
+     .visit_field::<f32>("inf_default", Self::VT_INF_DEFAULT, false)?
+     .visit_field::<f32>("positive_inf_default", Self::VT_POSITIVE_INF_DEFAULT, false)?
+     .visit_field::<f32>("infinity_default", Self::VT_INFINITY_DEFAULT, false)?
+     .visit_field::<f32>("positive_infinity_default", Self::VT_POSITIVE_INFINITY_DEFAULT, false)?
+     .visit_field::<f32>("negative_inf_default", Self::VT_NEGATIVE_INF_DEFAULT, false)?
+     .visit_field::<f32>("negative_infinity_default", Self::VT_NEGATIVE_INFINITY_DEFAULT, false)?
+     .visit_field::<f64>("double_inf_default", Self::VT_DOUBLE_INF_DEFAULT, false)?
      .finish();
     Ok(())
   }
@@ -1036,6 +1132,14 @@ pub struct MonsterArgs<'a> {
     pub native_inline: Option<&'a Test>,
     pub long_enum_non_enum_default: LongEnum,
     pub long_enum_normal_default: LongEnum,
+    pub nan_default: f32,
+    pub inf_default: f32,
+    pub positive_inf_default: f32,
+    pub infinity_default: f32,
+    pub positive_infinity_default: f32,
+    pub negative_inf_default: f32,
+    pub negative_infinity_default: f32,
+    pub double_inf_default: f64,
 }
 impl<'a> Default for MonsterArgs<'a> {
   #[inline]
@@ -1094,6 +1198,14 @@ impl<'a> Default for MonsterArgs<'a> {
       native_inline: None,
       long_enum_non_enum_default: Default::default(),
       long_enum_normal_default: LongEnum::LongOne,
+      nan_default: f32::NAN,
+      inf_default: f32::INFINITY,
+      positive_inf_default: f32::INFINITY,
+      infinity_default: f32::INFINITY,
+      positive_infinity_default: f32::INFINITY,
+      negative_inf_default: f32::NEG_INFINITY,
+      negative_infinity_default: f32::NEG_INFINITY,
+      double_inf_default: f64::INFINITY,
     }
   }
 }
@@ -1316,6 +1428,38 @@ impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> {
     self.fbb_.push_slot::<LongEnum>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, long_enum_normal_default, LongEnum::LongOne);
   }
   #[inline]
+  pub fn add_nan_default(&mut self, nan_default: f32) {
+    self.fbb_.push_slot::<f32>(Monster::VT_NAN_DEFAULT, nan_default, f32::NAN);
+  }
+  #[inline]
+  pub fn add_inf_default(&mut self, inf_default: f32) {
+    self.fbb_.push_slot::<f32>(Monster::VT_INF_DEFAULT, inf_default, f32::INFINITY);
+  }
+  #[inline]
+  pub fn add_positive_inf_default(&mut self, positive_inf_default: f32) {
+    self.fbb_.push_slot::<f32>(Monster::VT_POSITIVE_INF_DEFAULT, positive_inf_default, f32::INFINITY);
+  }
+  #[inline]
+  pub fn add_infinity_default(&mut self, infinity_default: f32) {
+    self.fbb_.push_slot::<f32>(Monster::VT_INFINITY_DEFAULT, infinity_default, f32::INFINITY);
+  }
+  #[inline]
+  pub fn add_positive_infinity_default(&mut self, positive_infinity_default: f32) {
+    self.fbb_.push_slot::<f32>(Monster::VT_POSITIVE_INFINITY_DEFAULT, positive_infinity_default, f32::INFINITY);
+  }
+  #[inline]
+  pub fn add_negative_inf_default(&mut self, negative_inf_default: f32) {
+    self.fbb_.push_slot::<f32>(Monster::VT_NEGATIVE_INF_DEFAULT, negative_inf_default, f32::NEG_INFINITY);
+  }
+  #[inline]
+  pub fn add_negative_infinity_default(&mut self, negative_infinity_default: f32) {
+    self.fbb_.push_slot::<f32>(Monster::VT_NEGATIVE_INFINITY_DEFAULT, negative_infinity_default, f32::NEG_INFINITY);
+  }
+  #[inline]
+  pub fn add_double_inf_default(&mut self, double_inf_default: f64) {
+    self.fbb_.push_slot::<f64>(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, f64::INFINITY);
+  }
+  #[inline]
   pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MonsterBuilder<'a, 'b> {
     let start = _fbb.start_table();
     MonsterBuilder {
@@ -1465,6 +1609,14 @@ impl core::fmt::Debug for Monster<'_> {
       ds.field("native_inline", &self.native_inline());
       ds.field("long_enum_non_enum_default", &self.long_enum_non_enum_default());
       ds.field("long_enum_normal_default", &self.long_enum_normal_default());
+      ds.field("nan_default", &self.nan_default());
+      ds.field("inf_default", &self.inf_default());
+      ds.field("positive_inf_default", &self.positive_inf_default());
+      ds.field("infinity_default", &self.infinity_default());
+      ds.field("positive_infinity_default", &self.positive_infinity_default());
+      ds.field("negative_inf_default", &self.negative_inf_default());
+      ds.field("negative_infinity_default", &self.negative_infinity_default());
+      ds.field("double_inf_default", &self.double_inf_default());
       ds.finish()
   }
 }
@@ -1521,6 +1673,14 @@ pub struct MonsterT {
   pub native_inline: Option<TestT>,
   pub long_enum_non_enum_default: LongEnum,
   pub long_enum_normal_default: LongEnum,
+  pub nan_default: f32,
+  pub inf_default: f32,
+  pub positive_inf_default: f32,
+  pub infinity_default: f32,
+  pub positive_infinity_default: f32,
+  pub negative_inf_default: f32,
+  pub negative_infinity_default: f32,
+  pub double_inf_default: f64,
 }
 impl Default for MonsterT {
   fn default() -> Self {
@@ -1575,6 +1735,14 @@ impl Default for MonsterT {
       native_inline: None,
       long_enum_non_enum_default: Default::default(),
       long_enum_normal_default: LongEnum::LongOne,
+      nan_default: f32::NAN,
+      inf_default: f32::INFINITY,
+      positive_inf_default: f32::INFINITY,
+      infinity_default: f32::INFINITY,
+      positive_infinity_default: f32::INFINITY,
+      negative_inf_default: f32::NEG_INFINITY,
+      negative_infinity_default: f32::NEG_INFINITY,
+      double_inf_default: f64::INFINITY,
     }
   }
 }
@@ -1687,6 +1855,14 @@ impl MonsterT {
     let native_inline = native_inline_tmp.as_ref();
     let long_enum_non_enum_default = self.long_enum_non_enum_default;
     let long_enum_normal_default = self.long_enum_normal_default;
+    let nan_default = self.nan_default;
+    let inf_default = self.inf_default;
+    let positive_inf_default = self.positive_inf_default;
+    let infinity_default = self.infinity_default;
+    let positive_infinity_default = self.positive_infinity_default;
+    let negative_inf_default = self.negative_inf_default;
+    let negative_infinity_default = self.negative_infinity_default;
+    let double_inf_default = self.double_inf_default;
     Monster::create(_fbb, &MonsterArgs{
       pos,
       mana,
@@ -1741,6 +1917,14 @@ impl MonsterT {
       native_inline,
       long_enum_non_enum_default,
       long_enum_normal_default,
+      nan_default,
+      inf_default,
+      positive_inf_default,
+      infinity_default,
+      positive_infinity_default,
+      negative_inf_default,
+      negative_infinity_default,
+      double_inf_default,
     })
   }
 }

tests/monster_test_generated.h

@@ -1309,6 +1309,14 @@ struct MonsterT : public flatbuffers::NativeTable {
   MyGame::Example::Test native_inline{};
   MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0);
   MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne;
+  float nan_default = std::numeric_limits<float>::quiet_NaN();
+  float inf_default = std::numeric_limits<float>::infinity();
+  float positive_inf_default = std::numeric_limits<float>::infinity();
+  float infinity_default = std::numeric_limits<float>::infinity();
+  float positive_infinity_default = std::numeric_limits<float>::infinity();
+  float negative_inf_default = -std::numeric_limits<float>::infinity();
+  float negative_infinity_default = -std::numeric_limits<float>::infinity();
+  double double_inf_default = std::numeric_limits<double>::infinity();
   MonsterT() = default;
   MonsterT(const MonsterT &o);
   MonsterT(MonsterT&&) FLATBUFFERS_NOEXCEPT = default;
@@ -1375,7 +1383,15 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_SCALAR_KEY_SORTED_TABLES = 104,
     VT_NATIVE_INLINE = 106,
     VT_LONG_ENUM_NON_ENUM_DEFAULT = 108,
-    VT_LONG_ENUM_NORMAL_DEFAULT = 110
+    VT_LONG_ENUM_NORMAL_DEFAULT = 110,
+    VT_NAN_DEFAULT = 112,
+    VT_INF_DEFAULT = 114,
+    VT_POSITIVE_INF_DEFAULT = 116,
+    VT_INFINITY_DEFAULT = 118,
+    VT_POSITIVE_INFINITY_DEFAULT = 120,
+    VT_NEGATIVE_INF_DEFAULT = 122,
+    VT_NEGATIVE_INFINITY_DEFAULT = 124,
+    VT_DOUBLE_INF_DEFAULT = 126
   };
   const MyGame::Example::Vec3 *pos() const {
     return GetStruct<const MyGame::Example::Vec3 *>(VT_POS);
@@ -1732,6 +1748,54 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   bool mutate_long_enum_normal_default(MyGame::Example::LongEnum _long_enum_normal_default = static_cast<MyGame::Example::LongEnum>(2ULL)) {
     return SetField<uint64_t>(VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(_long_enum_normal_default), 2ULL);
   }
+  float nan_default() const {
+    return GetField<float>(VT_NAN_DEFAULT, std::numeric_limits<float>::quiet_NaN());
+  }
+  bool mutate_nan_default(float _nan_default = std::numeric_limits<float>::quiet_NaN()) {
+    return SetField<float>(VT_NAN_DEFAULT, _nan_default, std::numeric_limits<float>::quiet_NaN());
+  }
+  float inf_default() const {
+    return GetField<float>(VT_INF_DEFAULT, std::numeric_limits<float>::infinity());
+  }
+  bool mutate_inf_default(float _inf_default = std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_INF_DEFAULT, _inf_default, std::numeric_limits<float>::infinity());
+  }
+  float positive_inf_default() const {
+    return GetField<float>(VT_POSITIVE_INF_DEFAULT, std::numeric_limits<float>::infinity());
+  }
+  bool mutate_positive_inf_default(float _positive_inf_default = std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_POSITIVE_INF_DEFAULT, _positive_inf_default, std::numeric_limits<float>::infinity());
+  }
+  float infinity_default() const {
+    return GetField<float>(VT_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
+  }
+  bool mutate_infinity_default(float _infinity_default = std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_INFINITY_DEFAULT, _infinity_default, std::numeric_limits<float>::infinity());
+  }
+  float positive_infinity_default() const {
+    return GetField<float>(VT_POSITIVE_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
+  }
+  bool mutate_positive_infinity_default(float _positive_infinity_default = std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_POSITIVE_INFINITY_DEFAULT, _positive_infinity_default, std::numeric_limits<float>::infinity());
+  }
+  float negative_inf_default() const {
+    return GetField<float>(VT_NEGATIVE_INF_DEFAULT, -std::numeric_limits<float>::infinity());
+  }
+  bool mutate_negative_inf_default(float _negative_inf_default = -std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_NEGATIVE_INF_DEFAULT, _negative_inf_default, -std::numeric_limits<float>::infinity());
+  }
+  float negative_infinity_default() const {
+    return GetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, -std::numeric_limits<float>::infinity());
+  }
+  bool mutate_negative_infinity_default(float _negative_infinity_default = -std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, _negative_infinity_default, -std::numeric_limits<float>::infinity());
+  }
+  double double_inf_default() const {
+    return GetField<double>(VT_DOUBLE_INF_DEFAULT, std::numeric_limits<double>::infinity());
+  }
+  bool mutate_double_inf_default(double _double_inf_default = std::numeric_limits<double>::infinity()) {
+    return SetField<double>(VT_DOUBLE_INF_DEFAULT, _double_inf_default, std::numeric_limits<double>::infinity());
+  }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
@@ -1823,6 +1887,14 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
            VerifyField<MyGame::Example::Test>(verifier, VT_NATIVE_INLINE, 2) &&
            VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NON_ENUM_DEFAULT, 8) &&
            VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NORMAL_DEFAULT, 8) &&
+           VerifyField<float>(verifier, VT_NAN_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_INF_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_POSITIVE_INF_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_INFINITY_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_POSITIVE_INFINITY_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_NEGATIVE_INF_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_NEGATIVE_INFINITY_DEFAULT, 4) &&
+           VerifyField<double>(verifier, VT_DOUBLE_INF_DEFAULT, 8) &&
            verifier.EndTable();
   }
   MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -2017,6 +2089,30 @@ struct MonsterBuilder {
   void add_long_enum_normal_default(MyGame::Example::LongEnum long_enum_normal_default) {
     fbb_.AddElement<uint64_t>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(long_enum_normal_default), 2ULL);
   }
+  void add_nan_default(float nan_default) {
+    fbb_.AddElement<float>(Monster::VT_NAN_DEFAULT, nan_default, std::numeric_limits<float>::quiet_NaN());
+  }
+  void add_inf_default(float inf_default) {
+    fbb_.AddElement<float>(Monster::VT_INF_DEFAULT, inf_default, std::numeric_limits<float>::infinity());
+  }
+  void add_positive_inf_default(float positive_inf_default) {
+    fbb_.AddElement<float>(Monster::VT_POSITIVE_INF_DEFAULT, positive_inf_default, std::numeric_limits<float>::infinity());
+  }
+  void add_infinity_default(float infinity_default) {
+    fbb_.AddElement<float>(Monster::VT_INFINITY_DEFAULT, infinity_default, std::numeric_limits<float>::infinity());
+  }
+  void add_positive_infinity_default(float positive_infinity_default) {
+    fbb_.AddElement<float>(Monster::VT_POSITIVE_INFINITY_DEFAULT, positive_infinity_default, std::numeric_limits<float>::infinity());
+  }
+  void add_negative_inf_default(float negative_inf_default) {
+    fbb_.AddElement<float>(Monster::VT_NEGATIVE_INF_DEFAULT, negative_inf_default, -std::numeric_limits<float>::infinity());
+  }
+  void add_negative_infinity_default(float negative_infinity_default) {
+    fbb_.AddElement<float>(Monster::VT_NEGATIVE_INFINITY_DEFAULT, negative_infinity_default, -std::numeric_limits<float>::infinity());
+  }
+  void add_double_inf_default(double double_inf_default) {
+    fbb_.AddElement<double>(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, std::numeric_limits<double>::infinity());
+  }
   explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -2083,8 +2179,17 @@ inline flatbuffers::Offset<Monster> CreateMonster(
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables = 0,
     const MyGame::Example::Test *native_inline = nullptr,
     MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
-    MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne) {
+    MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne,
+    float nan_default = std::numeric_limits<float>::quiet_NaN(),
+    float inf_default = std::numeric_limits<float>::infinity(),
+    float positive_inf_default = std::numeric_limits<float>::infinity(),
+    float infinity_default = std::numeric_limits<float>::infinity(),
+    float positive_infinity_default = std::numeric_limits<float>::infinity(),
+    float negative_inf_default = -std::numeric_limits<float>::infinity(),
+    float negative_infinity_default = -std::numeric_limits<float>::infinity(),
+    double double_inf_default = std::numeric_limits<double>::infinity()) {
   MonsterBuilder builder_(_fbb);
+  builder_.add_double_inf_default(double_inf_default);
   builder_.add_long_enum_normal_default(long_enum_normal_default);
   builder_.add_long_enum_non_enum_default(long_enum_non_enum_default);
   builder_.add_non_owning_reference(non_owning_reference);
@@ -2094,6 +2199,13 @@ inline flatbuffers::Offset<Monster> CreateMonster(
   builder_.add_testhashs64_fnv1a(testhashs64_fnv1a);
   builder_.add_testhashu64_fnv1(testhashu64_fnv1);
   builder_.add_testhashs64_fnv1(testhashs64_fnv1);
+  builder_.add_negative_infinity_default(negative_infinity_default);
+  builder_.add_negative_inf_default(negative_inf_default);
+  builder_.add_positive_infinity_default(positive_infinity_default);
+  builder_.add_infinity_default(infinity_default);
+  builder_.add_positive_inf_default(positive_inf_default);
+  builder_.add_inf_default(inf_default);
+  builder_.add_nan_default(nan_default);
   builder_.add_native_inline(native_inline);
   builder_.add_scalar_key_sorted_tables(scalar_key_sorted_tables);
   builder_.add_testrequirednestedflatbuffer(testrequirednestedflatbuffer);
@@ -2195,7 +2307,15 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
     std::vector<flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables = nullptr,
     const MyGame::Example::Test *native_inline = nullptr,
     MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
-    MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne) {
+    MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne,
+    float nan_default = std::numeric_limits<float>::quiet_NaN(),
+    float inf_default = std::numeric_limits<float>::infinity(),
+    float positive_inf_default = std::numeric_limits<float>::infinity(),
+    float infinity_default = std::numeric_limits<float>::infinity(),
+    float positive_infinity_default = std::numeric_limits<float>::infinity(),
+    float negative_inf_default = -std::numeric_limits<float>::infinity(),
+    float negative_infinity_default = -std::numeric_limits<float>::infinity(),
+    double double_inf_default = std::numeric_limits<double>::infinity()) {
   auto name__ = name ? _fbb.CreateString(name) : 0;
   auto inventory__ = inventory ? _fbb.CreateVector<uint8_t>(*inventory) : 0;
   auto test4__ = test4 ? _fbb.CreateVectorOfStructs<MyGame::Example::Test>(*test4) : 0;
@@ -2271,7 +2391,15 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
       scalar_key_sorted_tables__,
       native_inline,
       long_enum_non_enum_default,
-      long_enum_normal_default);
+      long_enum_normal_default,
+      nan_default,
+      inf_default,
+      positive_inf_default,
+      infinity_default,
+      positive_infinity_default,
+      negative_inf_default,
+      negative_infinity_default,
+      double_inf_default);
 }
 
 flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -2767,7 +2895,15 @@ inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) {
       (lhs.scalar_key_sorted_tables.size() == rhs.scalar_key_sorted_tables.size() && std::equal(lhs.scalar_key_sorted_tables.cbegin(), lhs.scalar_key_sorted_tables.cend(), rhs.scalar_key_sorted_tables.cbegin(), [](flatbuffers::unique_ptr<MyGame::Example::StatT> const &a, flatbuffers::unique_ptr<MyGame::Example::StatT> const &b) { return (a == b) || (a && b && *a == *b); })) &&
       (lhs.native_inline == rhs.native_inline) &&
       (lhs.long_enum_non_enum_default == rhs.long_enum_non_enum_default) &&
-      (lhs.long_enum_normal_default == rhs.long_enum_normal_default);
+      (lhs.long_enum_normal_default == rhs.long_enum_normal_default) &&
+      (lhs.nan_default == rhs.nan_default) &&
+      (lhs.inf_default == rhs.inf_default) &&
+      (lhs.positive_inf_default == rhs.positive_inf_default) &&
+      (lhs.infinity_default == rhs.infinity_default) &&
+      (lhs.positive_infinity_default == rhs.positive_infinity_default) &&
+      (lhs.negative_inf_default == rhs.negative_inf_default) &&
+      (lhs.negative_infinity_default == rhs.negative_infinity_default) &&
+      (lhs.double_inf_default == rhs.double_inf_default);
 }
 
 inline bool operator!=(const MonsterT &lhs, const MonsterT &rhs) {
@@ -2820,7 +2956,15 @@ inline MonsterT::MonsterT(const MonsterT &o)
         testrequirednestedflatbuffer(o.testrequirednestedflatbuffer),
         native_inline(o.native_inline),
         long_enum_non_enum_default(o.long_enum_non_enum_default),
-        long_enum_normal_default(o.long_enum_normal_default) {
+        long_enum_normal_default(o.long_enum_normal_default),
+        nan_default(o.nan_default),
+        inf_default(o.inf_default),
+        positive_inf_default(o.positive_inf_default),
+        infinity_default(o.infinity_default),
+        positive_infinity_default(o.positive_infinity_default),
+        negative_inf_default(o.negative_inf_default),
+        negative_infinity_default(o.negative_infinity_default),
+        double_inf_default(o.double_inf_default) {
   testarrayoftables.reserve(o.testarrayoftables.size());
   for (const auto &testarrayoftables_ : o.testarrayoftables) { testarrayoftables.emplace_back((testarrayoftables_) ? new MyGame::Example::MonsterT(*testarrayoftables_) : nullptr); }
   vector_of_referrables.reserve(o.vector_of_referrables.size());
@@ -2884,6 +3028,14 @@ inline MonsterT &MonsterT::operator=(MonsterT o) FLATBUFFERS_NOEXCEPT {
   std::swap(native_inline, o.native_inline);
   std::swap(long_enum_non_enum_default, o.long_enum_non_enum_default);
   std::swap(long_enum_normal_default, o.long_enum_normal_default);
+  std::swap(nan_default, o.nan_default);
+  std::swap(inf_default, o.inf_default);
+  std::swap(positive_inf_default, o.positive_inf_default);
+  std::swap(infinity_default, o.infinity_default);
+  std::swap(positive_infinity_default, o.positive_infinity_default);
+  std::swap(negative_inf_default, o.negative_inf_default);
+  std::swap(negative_infinity_default, o.negative_infinity_default);
+  std::swap(double_inf_default, o.double_inf_default);
   return *this;
 }
 
@@ -2949,6 +3101,14 @@ inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function
   { auto _e = native_inline(); if (_e) _o->native_inline = *_e; }
   { auto _e = long_enum_non_enum_default(); _o->long_enum_non_enum_default = _e; }
   { auto _e = long_enum_normal_default(); _o->long_enum_normal_default = _e; }
+  { auto _e = nan_default(); _o->nan_default = _e; }
+  { auto _e = inf_default(); _o->inf_default = _e; }
+  { auto _e = positive_inf_default(); _o->positive_inf_default = _e; }
+  { auto _e = infinity_default(); _o->infinity_default = _e; }
+  { auto _e = positive_infinity_default(); _o->positive_infinity_default = _e; }
+  { auto _e = negative_inf_default(); _o->negative_inf_default = _e; }
+  { auto _e = negative_infinity_default(); _o->negative_infinity_default = _e; }
+  { auto _e = double_inf_default(); _o->double_inf_default = _e; }
 }
 
 inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -3012,6 +3172,14 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
   auto _native_inline = &_o->native_inline;
   auto _long_enum_non_enum_default = _o->long_enum_non_enum_default;
   auto _long_enum_normal_default = _o->long_enum_normal_default;
+  auto _nan_default = _o->nan_default;
+  auto _inf_default = _o->inf_default;
+  auto _positive_inf_default = _o->positive_inf_default;
+  auto _infinity_default = _o->infinity_default;
+  auto _positive_infinity_default = _o->positive_infinity_default;
+  auto _negative_inf_default = _o->negative_inf_default;
+  auto _negative_infinity_default = _o->negative_infinity_default;
+  auto _double_inf_default = _o->double_inf_default;
   return MyGame::Example::CreateMonster(
       _fbb,
       _pos,
@@ -3066,7 +3234,15 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
       _scalar_key_sorted_tables,
       _native_inline,
       _long_enum_non_enum_default,
-      _long_enum_normal_default);
+      _long_enum_normal_default,
+      _nan_default,
+      _inf_default,
+      _positive_inf_default,
+      _infinity_default,
+      _positive_infinity_default,
+      _negative_inf_default,
+      _negative_infinity_default,
+      _double_inf_default);
 }
 
 
@@ -3846,7 +4022,15 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
     { flatbuffers::ET_SEQUENCE, 1, 5 },
     { flatbuffers::ET_SEQUENCE, 0, 3 },
     { flatbuffers::ET_ULONG, 0, 12 },
-    { flatbuffers::ET_ULONG, 0, 12 }
+    { flatbuffers::ET_ULONG, 0, 12 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_DOUBLE, 0, -1 }
   };
   static const flatbuffers::TypeFunction type_refs[] = {
     MyGame::Example::Vec3TypeTable,
@@ -3917,10 +4101,18 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
     "scalar_key_sorted_tables",
     "native_inline",
     "long_enum_non_enum_default",
-    "long_enum_normal_default"
+    "long_enum_normal_default",
+    "nan_default",
+    "inf_default",
+    "positive_inf_default",
+    "infinity_default",
+    "positive_infinity_default",
+    "negative_inf_default",
+    "negative_infinity_default",
+    "double_inf_default"
   };
   static const flatbuffers::TypeTable tt = {
-    flatbuffers::ST_TABLE, 54, type_codes, type_refs, nullptr, nullptr, names
+    flatbuffers::ST_TABLE, 62, type_codes, type_refs, nullptr, nullptr, names
   };
   return &tt;
 }

tests/monster_test_generated.lobster

@@ -425,13 +425,29 @@ class Monster : flatbuffers_handle
         return LongEnum(buf_.flatbuffers_field_uint64(pos_, 108, 0))
     def long_enum_normal_default() -> LongEnum:
         return LongEnum(buf_.flatbuffers_field_uint64(pos_, 110, 2))
+    def nan_default() -> float:
+        return buf_.flatbuffers_field_float32(pos_, 112, nan)
+    def inf_default() -> float:
+        return buf_.flatbuffers_field_float32(pos_, 114, inf)
+    def positive_inf_default() -> float:
+        return buf_.flatbuffers_field_float32(pos_, 116, +inf)
+    def infinity_default() -> float:
+        return buf_.flatbuffers_field_float32(pos_, 118, infinity)
+    def positive_infinity_default() -> float:
+        return buf_.flatbuffers_field_float32(pos_, 120, +infinity)
+    def negative_inf_default() -> float:
+        return buf_.flatbuffers_field_float32(pos_, 122, -inf)
+    def negative_infinity_default() -> float:
+        return buf_.flatbuffers_field_float32(pos_, 124, -infinity)
+    def double_inf_default() -> float:
+        return buf_.flatbuffers_field_float64(pos_, 126, inf)
 
 def GetRootAsMonster(buf:string): return Monster { buf, buf.flatbuffers_indirect(0) }
 
 struct MonsterBuilder:
     b_:flatbuffers_builder
     def start():
-        b_.StartObject(54)
+        b_.StartObject(62)
         return this
     def add_pos(pos:flatbuffers_offset):
         b_.PrependStructSlot(0, pos)
@@ -592,6 +608,30 @@ struct MonsterBuilder:
     def add_long_enum_normal_default(long_enum_normal_default:LongEnum):
         b_.PrependUint64Slot(53, long_enum_normal_default, 2)
         return this
+    def add_nan_default(nan_default:float):
+        b_.PrependFloat32Slot(54, nan_default, nan)
+        return this
+    def add_inf_default(inf_default:float):
+        b_.PrependFloat32Slot(55, inf_default, inf)
+        return this
+    def add_positive_inf_default(positive_inf_default:float):
+        b_.PrependFloat32Slot(56, positive_inf_default, +inf)
+        return this
+    def add_infinity_default(infinity_default:float):
+        b_.PrependFloat32Slot(57, infinity_default, infinity)
+        return this
+    def add_positive_infinity_default(positive_infinity_default:float):
+        b_.PrependFloat32Slot(58, positive_infinity_default, +infinity)
+        return this
+    def add_negative_inf_default(negative_inf_default:float):
+        b_.PrependFloat32Slot(59, negative_inf_default, -inf)
+        return this
+    def add_negative_infinity_default(negative_infinity_default:float):
+        b_.PrependFloat32Slot(60, negative_infinity_default, -infinity)
+        return this
+    def add_double_inf_default(double_inf_default:float):
+        b_.PrependFloat64Slot(61, double_inf_default, inf)
+        return this
     def end():
         return b_.EndObject()
 

tests/monster_test_generated.py

@@ -1615,7 +1615,63 @@ class Monster(object):
             return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
         return 2
 
-def MonsterStart(builder): builder.StartObject(54)
+    # Monster
+    def NanDefault(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(112))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return float('nan')
+
+    # Monster
+    def InfDefault(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(114))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return float('inf')
+
+    # Monster
+    def PositiveInfDefault(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(116))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return float('inf')
+
+    # Monster
+    def InfinityDefault(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(118))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return float('inf')
+
+    # Monster
+    def PositiveInfinityDefault(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(120))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return float('inf')
+
+    # Monster
+    def NegativeInfDefault(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(122))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return float('-inf')
+
+    # Monster
+    def NegativeInfinityDefault(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(124))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+        return float('-inf')
+
+    # Monster
+    def DoubleInfDefault(self):
+        o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(126))
+        if o != 0:
+            return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
+        return float('inf')
+
+def MonsterStart(builder): builder.StartObject(62)
 def MonsterAddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
 def MonsterAddMana(builder, mana): builder.PrependInt16Slot(1, mana, 150)
 def MonsterAddHp(builder, hp): builder.PrependInt16Slot(2, hp, 100)
@@ -1699,6 +1755,14 @@ def MonsterStartScalarKeySortedTablesVector(builder, numElems): return builder.S
 def MonsterAddNativeInline(builder, nativeInline): builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)
 def MonsterAddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault): builder.PrependUint64Slot(52, longEnumNonEnumDefault, 0)
 def MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault): builder.PrependUint64Slot(53, longEnumNormalDefault, 2)
+def MonsterAddNanDefault(builder, nanDefault): builder.PrependFloat32Slot(54, nanDefault, float('nan'))
+def MonsterAddInfDefault(builder, infDefault): builder.PrependFloat32Slot(55, infDefault, float('inf'))
+def MonsterAddPositiveInfDefault(builder, positiveInfDefault): builder.PrependFloat32Slot(56, positiveInfDefault, float('inf'))
+def MonsterAddInfinityDefault(builder, infinityDefault): builder.PrependFloat32Slot(57, infinityDefault, float('inf'))
+def MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault): builder.PrependFloat32Slot(58, positiveInfinityDefault, float('inf'))
+def MonsterAddNegativeInfDefault(builder, negativeInfDefault): builder.PrependFloat32Slot(59, negativeInfDefault, float('-inf'))
+def MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault): builder.PrependFloat32Slot(60, negativeInfinityDefault, float('-inf'))
+def MonsterAddDoubleInfDefault(builder, doubleInfDefault): builder.PrependFloat64Slot(61, doubleInfDefault, float('inf'))
 def MonsterEnd(builder): return builder.EndObject()
 
 try:
@@ -1763,6 +1827,14 @@ class MonsterT(object):
         self.nativeInline = None  # type: Optional[TestT]
         self.longEnumNonEnumDefault = 0  # type: int
         self.longEnumNormalDefault = 2  # type: int
+        self.nanDefault = float('nan')  # type: float
+        self.infDefault = float('inf')  # type: float
+        self.positiveInfDefault = float('inf')  # type: float
+        self.infinityDefault = float('inf')  # type: float
+        self.positiveInfinityDefault = float('inf')  # type: float
+        self.negativeInfDefault = float('-inf')  # type: float
+        self.negativeInfinityDefault = float('-inf')  # type: float
+        self.doubleInfDefault = float('inf')  # type: float
 
     @classmethod
     def InitFromBuf(cls, buf, pos):
@@ -1964,6 +2036,14 @@ class MonsterT(object):
             self.nativeInline = TestT.InitFromObj(monster.NativeInline())
         self.longEnumNonEnumDefault = monster.LongEnumNonEnumDefault()
         self.longEnumNormalDefault = monster.LongEnumNormalDefault()
+        self.nanDefault = monster.NanDefault()
+        self.infDefault = monster.InfDefault()
+        self.positiveInfDefault = monster.PositiveInfDefault()
+        self.infinityDefault = monster.InfinityDefault()
+        self.positiveInfinityDefault = monster.PositiveInfinityDefault()
+        self.negativeInfDefault = monster.NegativeInfDefault()
+        self.negativeInfinityDefault = monster.NegativeInfinityDefault()
+        self.doubleInfDefault = monster.DoubleInfDefault()
 
     # MonsterT
     def Pack(self, builder):
@@ -2217,6 +2297,14 @@ class MonsterT(object):
             MonsterAddNativeInline(builder, nativeInline)
         MonsterAddLongEnumNonEnumDefault(builder, self.longEnumNonEnumDefault)
         MonsterAddLongEnumNormalDefault(builder, self.longEnumNormalDefault)
+        MonsterAddNanDefault(builder, self.nanDefault)
+        MonsterAddInfDefault(builder, self.infDefault)
+        MonsterAddPositiveInfDefault(builder, self.positiveInfDefault)
+        MonsterAddInfinityDefault(builder, self.infinityDefault)
+        MonsterAddPositiveInfinityDefault(builder, self.positiveInfinityDefault)
+        MonsterAddNegativeInfDefault(builder, self.negativeInfDefault)
+        MonsterAddNegativeInfinityDefault(builder, self.negativeInfinityDefault)
+        MonsterAddDoubleInfDefault(builder, self.doubleInfDefault)
         monster = MonsterEnd(builder)
         return monster
 

tests/monster_test_my_game.example_generated.dart

@@ -1258,10 +1258,18 @@ class Monster {
   Test? get nativeInline => Test.reader.vTableGetNullable(_bc, _bcOffset, 106);
   LongEnum get longEnumNonEnumDefault => LongEnum.fromValue(const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 108, 0));
   LongEnum get longEnumNormalDefault => LongEnum.fromValue(const fb.Uint64Reader().vTableGet(_bc, _bcOffset, 110, 2));
+  double get nanDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 112, double.nan);
+  double get infDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 114, double.infinity);
+  double get positiveInfDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 116, double.infinity);
+  double get infinityDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 118, double.infinity);
+  double get positiveInfinityDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 120, double.infinity);
+  double get negativeInfDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 122, double.negativeInfinity);
+  double get negativeInfinityDefault => const fb.Float32Reader().vTableGet(_bc, _bcOffset, 124, double.negativeInfinity);
+  double get doubleInfDefault => const fb.Float64Reader().vTableGet(_bc, _bcOffset, 126, double.infinity);
 
   @override
   String toString() {
-    return 'Monster{pos: ${pos}, mana: ${mana}, hp: ${hp}, name: ${name}, inventory: ${inventory}, color: ${color}, testType: ${testType}, test: ${test}, test4: ${test4}, testarrayofstring: ${testarrayofstring}, testarrayoftables: ${testarrayoftables}, enemy: ${enemy}, testnestedflatbuffer: ${testnestedflatbuffer}, testempty: ${testempty}, testbool: ${testbool}, testhashs32Fnv1: ${testhashs32Fnv1}, testhashu32Fnv1: ${testhashu32Fnv1}, testhashs64Fnv1: ${testhashs64Fnv1}, testhashu64Fnv1: ${testhashu64Fnv1}, testhashs32Fnv1a: ${testhashs32Fnv1a}, testhashu32Fnv1a: ${testhashu32Fnv1a}, testhashs64Fnv1a: ${testhashs64Fnv1a}, testhashu64Fnv1a: ${testhashu64Fnv1a}, testarrayofbools: ${testarrayofbools}, testf: ${testf}, testf2: ${testf2}, testf3: ${testf3}, testarrayofstring2: ${testarrayofstring2}, testarrayofsortedstruct: ${testarrayofsortedstruct}, flex: ${flex}, test5: ${test5}, vectorOfLongs: ${vectorOfLongs}, vectorOfDoubles: ${vectorOfDoubles}, parentNamespaceTest: ${parentNamespaceTest}, vectorOfReferrables: ${vectorOfReferrables}, singleWeakReference: ${singleWeakReference}, vectorOfWeakReferences: ${vectorOfWeakReferences}, vectorOfStrongReferrables: ${vectorOfStrongReferrables}, coOwningReference: ${coOwningReference}, vectorOfCoOwningReferences: ${vectorOfCoOwningReferences}, nonOwningReference: ${nonOwningReference}, vectorOfNonOwningReferences: ${vectorOfNonOwningReferences}, anyUniqueType: ${anyUniqueType}, anyUnique: ${anyUnique}, anyAmbiguousType: ${anyAmbiguousType}, anyAmbiguous: ${anyAmbiguous}, vectorOfEnums: ${vectorOfEnums}, signedEnum: ${signedEnum}, testrequirednestedflatbuffer: ${testrequirednestedflatbuffer}, scalarKeySortedTables: ${scalarKeySortedTables}, nativeInline: ${nativeInline}, longEnumNonEnumDefault: ${longEnumNonEnumDefault}, longEnumNormalDefault: ${longEnumNormalDefault}}';
+    return 'Monster{pos: ${pos}, mana: ${mana}, hp: ${hp}, name: ${name}, inventory: ${inventory}, color: ${color}, testType: ${testType}, test: ${test}, test4: ${test4}, testarrayofstring: ${testarrayofstring}, testarrayoftables: ${testarrayoftables}, enemy: ${enemy}, testnestedflatbuffer: ${testnestedflatbuffer}, testempty: ${testempty}, testbool: ${testbool}, testhashs32Fnv1: ${testhashs32Fnv1}, testhashu32Fnv1: ${testhashu32Fnv1}, testhashs64Fnv1: ${testhashs64Fnv1}, testhashu64Fnv1: ${testhashu64Fnv1}, testhashs32Fnv1a: ${testhashs32Fnv1a}, testhashu32Fnv1a: ${testhashu32Fnv1a}, testhashs64Fnv1a: ${testhashs64Fnv1a}, testhashu64Fnv1a: ${testhashu64Fnv1a}, testarrayofbools: ${testarrayofbools}, testf: ${testf}, testf2: ${testf2}, testf3: ${testf3}, testarrayofstring2: ${testarrayofstring2}, testarrayofsortedstruct: ${testarrayofsortedstruct}, flex: ${flex}, test5: ${test5}, vectorOfLongs: ${vectorOfLongs}, vectorOfDoubles: ${vectorOfDoubles}, parentNamespaceTest: ${parentNamespaceTest}, vectorOfReferrables: ${vectorOfReferrables}, singleWeakReference: ${singleWeakReference}, vectorOfWeakReferences: ${vectorOfWeakReferences}, vectorOfStrongReferrables: ${vectorOfStrongReferrables}, coOwningReference: ${coOwningReference}, vectorOfCoOwningReferences: ${vectorOfCoOwningReferences}, nonOwningReference: ${nonOwningReference}, vectorOfNonOwningReferences: ${vectorOfNonOwningReferences}, anyUniqueType: ${anyUniqueType}, anyUnique: ${anyUnique}, anyAmbiguousType: ${anyAmbiguousType}, anyAmbiguous: ${anyAmbiguous}, vectorOfEnums: ${vectorOfEnums}, signedEnum: ${signedEnum}, testrequirednestedflatbuffer: ${testrequirednestedflatbuffer}, scalarKeySortedTables: ${scalarKeySortedTables}, nativeInline: ${nativeInline}, longEnumNonEnumDefault: ${longEnumNonEnumDefault}, longEnumNormalDefault: ${longEnumNormalDefault}, nanDefault: ${nanDefault}, infDefault: ${infDefault}, positiveInfDefault: ${positiveInfDefault}, infinityDefault: ${infinityDefault}, positiveInfinityDefault: ${positiveInfinityDefault}, negativeInfDefault: ${negativeInfDefault}, negativeInfinityDefault: ${negativeInfinityDefault}, doubleInfDefault: ${doubleInfDefault}}';
   }
 
   MonsterT unpack() => MonsterT(
@@ -1317,7 +1325,15 @@ class Monster {
       scalarKeySortedTables: scalarKeySortedTables?.map((e) => e.unpack()).toList(),
       nativeInline: nativeInline?.unpack(),
       longEnumNonEnumDefault: longEnumNonEnumDefault,
-      longEnumNormalDefault: longEnumNormalDefault);
+      longEnumNormalDefault: longEnumNormalDefault,
+      nanDefault: nanDefault,
+      infDefault: infDefault,
+      positiveInfDefault: positiveInfDefault,
+      infinityDefault: infinityDefault,
+      positiveInfinityDefault: positiveInfinityDefault,
+      negativeInfDefault: negativeInfDefault,
+      negativeInfinityDefault: negativeInfinityDefault,
+      doubleInfDefault: doubleInfDefault);
 
   static int pack(fb.Builder fbBuilder, MonsterT? object) {
     if (object == null) return 0;
@@ -1382,6 +1398,14 @@ class MonsterT implements fb.Packable {
   TestT? nativeInline;
   LongEnum longEnumNonEnumDefault;
   LongEnum longEnumNormalDefault;
+  double nanDefault;
+  double infDefault;
+  double positiveInfDefault;
+  double infinityDefault;
+  double positiveInfinityDefault;
+  double negativeInfDefault;
+  double negativeInfinityDefault;
+  double doubleInfDefault;
 
   MonsterT({
       this.pos,
@@ -1436,7 +1460,15 @@ class MonsterT implements fb.Packable {
       this.scalarKeySortedTables,
       this.nativeInline,
       this.longEnumNonEnumDefault = const LongEnum._(0),
-      this.longEnumNormalDefault = LongEnum.LongOne});
+      this.longEnumNormalDefault = LongEnum.LongOne,
+      this.nanDefault = double.nan,
+      this.infDefault = double.infinity,
+      this.positiveInfDefault = double.infinity,
+      this.infinityDefault = double.infinity,
+      this.positiveInfinityDefault = double.infinity,
+      this.negativeInfDefault = double.negativeInfinity,
+      this.negativeInfinityDefault = double.negativeInfinity,
+      this.doubleInfDefault = double.infinity});
 
   @override
   int pack(fb.Builder fbBuilder) {
@@ -1497,7 +1529,7 @@ class MonsterT implements fb.Packable {
         : fbBuilder.writeListUint8(testrequirednestedflatbuffer!);
     final int? scalarKeySortedTablesOffset = scalarKeySortedTables == null ? null
         : fbBuilder.writeList(scalarKeySortedTables!.map((b) => b.pack(fbBuilder)).toList());
-    fbBuilder.startTable(54);
+    fbBuilder.startTable(62);
     if (pos != null) {
       fbBuilder.addStruct(0, pos!.pack(fbBuilder));
     }
@@ -1555,12 +1587,20 @@ class MonsterT implements fb.Packable {
     }
     fbBuilder.addUint64(52, longEnumNonEnumDefault.value);
     fbBuilder.addUint64(53, longEnumNormalDefault.value);
+    fbBuilder.addFloat32(54, nanDefault);
+    fbBuilder.addFloat32(55, infDefault);
+    fbBuilder.addFloat32(56, positiveInfDefault);
+    fbBuilder.addFloat32(57, infinityDefault);
+    fbBuilder.addFloat32(58, positiveInfinityDefault);
+    fbBuilder.addFloat32(59, negativeInfDefault);
+    fbBuilder.addFloat32(60, negativeInfinityDefault);
+    fbBuilder.addFloat64(61, doubleInfDefault);
     return fbBuilder.endTable();
   }
 
   @override
   String toString() {
-    return 'MonsterT{pos: ${pos}, mana: ${mana}, hp: ${hp}, name: ${name}, inventory: ${inventory}, color: ${color}, testType: ${testType}, test: ${test}, test4: ${test4}, testarrayofstring: ${testarrayofstring}, testarrayoftables: ${testarrayoftables}, enemy: ${enemy}, testnestedflatbuffer: ${testnestedflatbuffer}, testempty: ${testempty}, testbool: ${testbool}, testhashs32Fnv1: ${testhashs32Fnv1}, testhashu32Fnv1: ${testhashu32Fnv1}, testhashs64Fnv1: ${testhashs64Fnv1}, testhashu64Fnv1: ${testhashu64Fnv1}, testhashs32Fnv1a: ${testhashs32Fnv1a}, testhashu32Fnv1a: ${testhashu32Fnv1a}, testhashs64Fnv1a: ${testhashs64Fnv1a}, testhashu64Fnv1a: ${testhashu64Fnv1a}, testarrayofbools: ${testarrayofbools}, testf: ${testf}, testf2: ${testf2}, testf3: ${testf3}, testarrayofstring2: ${testarrayofstring2}, testarrayofsortedstruct: ${testarrayofsortedstruct}, flex: ${flex}, test5: ${test5}, vectorOfLongs: ${vectorOfLongs}, vectorOfDoubles: ${vectorOfDoubles}, parentNamespaceTest: ${parentNamespaceTest}, vectorOfReferrables: ${vectorOfReferrables}, singleWeakReference: ${singleWeakReference}, vectorOfWeakReferences: ${vectorOfWeakReferences}, vectorOfStrongReferrables: ${vectorOfStrongReferrables}, coOwningReference: ${coOwningReference}, vectorOfCoOwningReferences: ${vectorOfCoOwningReferences}, nonOwningReference: ${nonOwningReference}, vectorOfNonOwningReferences: ${vectorOfNonOwningReferences}, anyUniqueType: ${anyUniqueType}, anyUnique: ${anyUnique}, anyAmbiguousType: ${anyAmbiguousType}, anyAmbiguous: ${anyAmbiguous}, vectorOfEnums: ${vectorOfEnums}, signedEnum: ${signedEnum}, testrequirednestedflatbuffer: ${testrequirednestedflatbuffer}, scalarKeySortedTables: ${scalarKeySortedTables}, nativeInline: ${nativeInline}, longEnumNonEnumDefault: ${longEnumNonEnumDefault}, longEnumNormalDefault: ${longEnumNormalDefault}}';
+    return 'MonsterT{pos: ${pos}, mana: ${mana}, hp: ${hp}, name: ${name}, inventory: ${inventory}, color: ${color}, testType: ${testType}, test: ${test}, test4: ${test4}, testarrayofstring: ${testarrayofstring}, testarrayoftables: ${testarrayoftables}, enemy: ${enemy}, testnestedflatbuffer: ${testnestedflatbuffer}, testempty: ${testempty}, testbool: ${testbool}, testhashs32Fnv1: ${testhashs32Fnv1}, testhashu32Fnv1: ${testhashu32Fnv1}, testhashs64Fnv1: ${testhashs64Fnv1}, testhashu64Fnv1: ${testhashu64Fnv1}, testhashs32Fnv1a: ${testhashs32Fnv1a}, testhashu32Fnv1a: ${testhashu32Fnv1a}, testhashs64Fnv1a: ${testhashs64Fnv1a}, testhashu64Fnv1a: ${testhashu64Fnv1a}, testarrayofbools: ${testarrayofbools}, testf: ${testf}, testf2: ${testf2}, testf3: ${testf3}, testarrayofstring2: ${testarrayofstring2}, testarrayofsortedstruct: ${testarrayofsortedstruct}, flex: ${flex}, test5: ${test5}, vectorOfLongs: ${vectorOfLongs}, vectorOfDoubles: ${vectorOfDoubles}, parentNamespaceTest: ${parentNamespaceTest}, vectorOfReferrables: ${vectorOfReferrables}, singleWeakReference: ${singleWeakReference}, vectorOfWeakReferences: ${vectorOfWeakReferences}, vectorOfStrongReferrables: ${vectorOfStrongReferrables}, coOwningReference: ${coOwningReference}, vectorOfCoOwningReferences: ${vectorOfCoOwningReferences}, nonOwningReference: ${nonOwningReference}, vectorOfNonOwningReferences: ${vectorOfNonOwningReferences}, anyUniqueType: ${anyUniqueType}, anyUnique: ${anyUnique}, anyAmbiguousType: ${anyAmbiguousType}, anyAmbiguous: ${anyAmbiguous}, vectorOfEnums: ${vectorOfEnums}, signedEnum: ${signedEnum}, testrequirednestedflatbuffer: ${testrequirednestedflatbuffer}, scalarKeySortedTables: ${scalarKeySortedTables}, nativeInline: ${nativeInline}, longEnumNonEnumDefault: ${longEnumNonEnumDefault}, longEnumNormalDefault: ${longEnumNormalDefault}, nanDefault: ${nanDefault}, infDefault: ${infDefault}, positiveInfDefault: ${positiveInfDefault}, infinityDefault: ${infinityDefault}, positiveInfinityDefault: ${positiveInfinityDefault}, negativeInfDefault: ${negativeInfDefault}, negativeInfinityDefault: ${negativeInfinityDefault}, doubleInfDefault: ${doubleInfDefault}}';
   }
 }
 
@@ -1578,7 +1618,7 @@ class MonsterBuilder {
   final fb.Builder fbBuilder;
 
   void begin() {
-    fbBuilder.startTable(54);
+    fbBuilder.startTable(62);
   }
 
   int addPos(int offset) {
@@ -1793,6 +1833,38 @@ class MonsterBuilder {
     fbBuilder.addUint64(53, longEnumNormalDefault?.value);
     return fbBuilder.offset;
   }
+  int addNanDefault(double? nanDefault) {
+    fbBuilder.addFloat32(54, nanDefault);
+    return fbBuilder.offset;
+  }
+  int addInfDefault(double? infDefault) {
+    fbBuilder.addFloat32(55, infDefault);
+    return fbBuilder.offset;
+  }
+  int addPositiveInfDefault(double? positiveInfDefault) {
+    fbBuilder.addFloat32(56, positiveInfDefault);
+    return fbBuilder.offset;
+  }
+  int addInfinityDefault(double? infinityDefault) {
+    fbBuilder.addFloat32(57, infinityDefault);
+    return fbBuilder.offset;
+  }
+  int addPositiveInfinityDefault(double? positiveInfinityDefault) {
+    fbBuilder.addFloat32(58, positiveInfinityDefault);
+    return fbBuilder.offset;
+  }
+  int addNegativeInfDefault(double? negativeInfDefault) {
+    fbBuilder.addFloat32(59, negativeInfDefault);
+    return fbBuilder.offset;
+  }
+  int addNegativeInfinityDefault(double? negativeInfinityDefault) {
+    fbBuilder.addFloat32(60, negativeInfinityDefault);
+    return fbBuilder.offset;
+  }
+  int addDoubleInfDefault(double? doubleInfDefault) {
+    fbBuilder.addFloat64(61, doubleInfDefault);
+    return fbBuilder.offset;
+  }
 
   int finish() {
     return fbBuilder.endTable();
@@ -1853,6 +1925,14 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
   final TestObjectBuilder? _nativeInline;
   final LongEnum? _longEnumNonEnumDefault;
   final LongEnum? _longEnumNormalDefault;
+  final double? _nanDefault;
+  final double? _infDefault;
+  final double? _positiveInfDefault;
+  final double? _infinityDefault;
+  final double? _positiveInfinityDefault;
+  final double? _negativeInfDefault;
+  final double? _negativeInfinityDefault;
+  final double? _doubleInfDefault;
 
   MonsterObjectBuilder({
     Vec3ObjectBuilder? pos,
@@ -1908,6 +1988,14 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
     TestObjectBuilder? nativeInline,
     LongEnum? longEnumNonEnumDefault,
     LongEnum? longEnumNormalDefault,
+    double? nanDefault,
+    double? infDefault,
+    double? positiveInfDefault,
+    double? infinityDefault,
+    double? positiveInfinityDefault,
+    double? negativeInfDefault,
+    double? negativeInfinityDefault,
+    double? doubleInfDefault,
   })
       : _pos = pos,
         _mana = mana,
@@ -1961,7 +2049,15 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
         _scalarKeySortedTables = scalarKeySortedTables,
         _nativeInline = nativeInline,
         _longEnumNonEnumDefault = longEnumNonEnumDefault,
-        _longEnumNormalDefault = longEnumNormalDefault;
+        _longEnumNormalDefault = longEnumNormalDefault,
+        _nanDefault = nanDefault,
+        _infDefault = infDefault,
+        _positiveInfDefault = positiveInfDefault,
+        _infinityDefault = infinityDefault,
+        _positiveInfinityDefault = positiveInfinityDefault,
+        _negativeInfDefault = negativeInfDefault,
+        _negativeInfinityDefault = negativeInfinityDefault,
+        _doubleInfDefault = doubleInfDefault;
 
   /// Finish building, and store into the [fbBuilder].
   @override
@@ -2014,7 +2110,7 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
         : fbBuilder.writeListUint8(_testrequirednestedflatbuffer!);
     final int? scalarKeySortedTablesOffset = _scalarKeySortedTables == null ? null
         : fbBuilder.writeList(_scalarKeySortedTables!.map((b) => b.getOrCreateOffset(fbBuilder)).toList());
-    fbBuilder.startTable(54);
+    fbBuilder.startTable(62);
     if (_pos != null) {
       fbBuilder.addStruct(0, _pos!.finish(fbBuilder));
     }
@@ -2072,6 +2168,14 @@ class MonsterObjectBuilder extends fb.ObjectBuilder {
     }
     fbBuilder.addUint64(52, _longEnumNonEnumDefault?.value);
     fbBuilder.addUint64(53, _longEnumNormalDefault?.value);
+    fbBuilder.addFloat32(54, _nanDefault);
+    fbBuilder.addFloat32(55, _infDefault);
+    fbBuilder.addFloat32(56, _positiveInfDefault);
+    fbBuilder.addFloat32(57, _infinityDefault);
+    fbBuilder.addFloat32(58, _positiveInfinityDefault);
+    fbBuilder.addFloat32(59, _negativeInfDefault);
+    fbBuilder.addFloat32(60, _negativeInfinityDefault);
+    fbBuilder.addFloat64(61, _doubleInfDefault);
     return fbBuilder.endTable();
   }
 

tests/monster_test_serialize/my_game/example/monster_generated.rs

@@ -81,6 +81,14 @@ impl<'a> Monster<'a> {
   pub const VT_NATIVE_INLINE: flatbuffers::VOffsetT = 106;
   pub const VT_LONG_ENUM_NON_ENUM_DEFAULT: flatbuffers::VOffsetT = 108;
   pub const VT_LONG_ENUM_NORMAL_DEFAULT: flatbuffers::VOffsetT = 110;
+  pub const VT_NAN_DEFAULT: flatbuffers::VOffsetT = 112;
+  pub const VT_INF_DEFAULT: flatbuffers::VOffsetT = 114;
+  pub const VT_POSITIVE_INF_DEFAULT: flatbuffers::VOffsetT = 116;
+  pub const VT_INFINITY_DEFAULT: flatbuffers::VOffsetT = 118;
+  pub const VT_POSITIVE_INFINITY_DEFAULT: flatbuffers::VOffsetT = 120;
+  pub const VT_NEGATIVE_INF_DEFAULT: flatbuffers::VOffsetT = 122;
+  pub const VT_NEGATIVE_INFINITY_DEFAULT: flatbuffers::VOffsetT = 124;
+  pub const VT_DOUBLE_INF_DEFAULT: flatbuffers::VOffsetT = 126;
 
   pub const fn get_fully_qualified_name() -> &'static str {
     "MyGame.Example.Monster"
@@ -96,6 +104,7 @@ impl<'a> Monster<'a> {
     args: &'args MonsterArgs<'args>
   ) -> flatbuffers::WIPOffset<Monster<'bldr>> {
     let mut builder = MonsterBuilder::new(_fbb);
+    builder.add_double_inf_default(args.double_inf_default);
     builder.add_long_enum_normal_default(args.long_enum_normal_default);
     builder.add_long_enum_non_enum_default(args.long_enum_non_enum_default);
     builder.add_non_owning_reference(args.non_owning_reference);
@@ -105,6 +114,13 @@ impl<'a> Monster<'a> {
     builder.add_testhashs64_fnv1a(args.testhashs64_fnv1a);
     builder.add_testhashu64_fnv1(args.testhashu64_fnv1);
     builder.add_testhashs64_fnv1(args.testhashs64_fnv1);
+    builder.add_negative_infinity_default(args.negative_infinity_default);
+    builder.add_negative_inf_default(args.negative_inf_default);
+    builder.add_positive_infinity_default(args.positive_infinity_default);
+    builder.add_infinity_default(args.infinity_default);
+    builder.add_positive_inf_default(args.positive_inf_default);
+    builder.add_inf_default(args.inf_default);
+    builder.add_nan_default(args.nan_default);
     if let Some(x) = args.native_inline { builder.add_native_inline(x); }
     if let Some(x) = args.scalar_key_sorted_tables { builder.add_scalar_key_sorted_tables(x); }
     if let Some(x) = args.testrequirednestedflatbuffer { builder.add_testrequirednestedflatbuffer(x); }
@@ -310,6 +326,14 @@ impl<'a> Monster<'a> {
     });
     let long_enum_non_enum_default = self.long_enum_non_enum_default();
     let long_enum_normal_default = self.long_enum_normal_default();
+    let nan_default = self.nan_default();
+    let inf_default = self.inf_default();
+    let positive_inf_default = self.positive_inf_default();
+    let infinity_default = self.infinity_default();
+    let positive_infinity_default = self.positive_infinity_default();
+    let negative_inf_default = self.negative_inf_default();
+    let negative_infinity_default = self.negative_infinity_default();
+    let double_inf_default = self.double_inf_default();
     MonsterT {
       pos,
       mana,
@@ -361,6 +385,14 @@ impl<'a> Monster<'a> {
       native_inline,
       long_enum_non_enum_default,
       long_enum_normal_default,
+      nan_default,
+      inf_default,
+      positive_inf_default,
+      infinity_default,
+      positive_infinity_default,
+      negative_inf_default,
+      negative_infinity_default,
+      double_inf_default,
     }
   }
 
@@ -766,6 +798,62 @@ impl<'a> Monster<'a> {
     unsafe { self._tab.get::<LongEnum>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, Some(LongEnum::LongOne)).unwrap()}
   }
   #[inline]
+  pub fn nan_default(&self) -> f32 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f32>(Monster::VT_NAN_DEFAULT, Some(f32::NAN)).unwrap()}
+  }
+  #[inline]
+  pub fn inf_default(&self) -> f32 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f32>(Monster::VT_INF_DEFAULT, Some(f32::INFINITY)).unwrap()}
+  }
+  #[inline]
+  pub fn positive_inf_default(&self) -> f32 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f32>(Monster::VT_POSITIVE_INF_DEFAULT, Some(f32::INFINITY)).unwrap()}
+  }
+  #[inline]
+  pub fn infinity_default(&self) -> f32 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f32>(Monster::VT_INFINITY_DEFAULT, Some(f32::INFINITY)).unwrap()}
+  }
+  #[inline]
+  pub fn positive_infinity_default(&self) -> f32 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f32>(Monster::VT_POSITIVE_INFINITY_DEFAULT, Some(f32::INFINITY)).unwrap()}
+  }
+  #[inline]
+  pub fn negative_inf_default(&self) -> f32 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f32>(Monster::VT_NEGATIVE_INF_DEFAULT, Some(f32::NEG_INFINITY)).unwrap()}
+  }
+  #[inline]
+  pub fn negative_infinity_default(&self) -> f32 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f32>(Monster::VT_NEGATIVE_INFINITY_DEFAULT, Some(f32::NEG_INFINITY)).unwrap()}
+  }
+  #[inline]
+  pub fn double_inf_default(&self) -> f64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<f64>(Monster::VT_DOUBLE_INF_DEFAULT, Some(f64::INFINITY)).unwrap()}
+  }
+  #[inline]
   #[allow(non_snake_case)]
   pub fn test_as_monster(&self) -> Option<Monster<'a>> {
     if self.test_type() == Any::Monster {
@@ -980,6 +1068,14 @@ impl flatbuffers::Verifiable for Monster<'_> {
      .visit_field::<Test>("native_inline", Self::VT_NATIVE_INLINE, false)?
      .visit_field::<LongEnum>("long_enum_non_enum_default", Self::VT_LONG_ENUM_NON_ENUM_DEFAULT, false)?
      .visit_field::<LongEnum>("long_enum_normal_default", Self::VT_LONG_ENUM_NORMAL_DEFAULT, false)?
+     .visit_field::<f32>("nan_default", Self::VT_NAN_DEFAULT, false)?
+     .visit_field::<f32>("inf_default", Self::VT_INF_DEFAULT, false)?
+     .visit_field::<f32>("positive_inf_default", Self::VT_POSITIVE_INF_DEFAULT, false)?
+     .visit_field::<f32>("infinity_default", Self::VT_INFINITY_DEFAULT, false)?
+     .visit_field::<f32>("positive_infinity_default", Self::VT_POSITIVE_INFINITY_DEFAULT, false)?
+     .visit_field::<f32>("negative_inf_default", Self::VT_NEGATIVE_INF_DEFAULT, false)?
+     .visit_field::<f32>("negative_infinity_default", Self::VT_NEGATIVE_INFINITY_DEFAULT, false)?
+     .visit_field::<f64>("double_inf_default", Self::VT_DOUBLE_INF_DEFAULT, false)?
      .finish();
     Ok(())
   }
@@ -1038,6 +1134,14 @@ pub struct MonsterArgs<'a> {
     pub native_inline: Option<&'a Test>,
     pub long_enum_non_enum_default: LongEnum,
     pub long_enum_normal_default: LongEnum,
+    pub nan_default: f32,
+    pub inf_default: f32,
+    pub positive_inf_default: f32,
+    pub infinity_default: f32,
+    pub positive_infinity_default: f32,
+    pub negative_inf_default: f32,
+    pub negative_infinity_default: f32,
+    pub double_inf_default: f64,
 }
 impl<'a> Default for MonsterArgs<'a> {
   #[inline]
@@ -1096,6 +1200,14 @@ impl<'a> Default for MonsterArgs<'a> {
       native_inline: None,
       long_enum_non_enum_default: Default::default(),
       long_enum_normal_default: LongEnum::LongOne,
+      nan_default: f32::NAN,
+      inf_default: f32::INFINITY,
+      positive_inf_default: f32::INFINITY,
+      infinity_default: f32::INFINITY,
+      positive_infinity_default: f32::INFINITY,
+      negative_inf_default: f32::NEG_INFINITY,
+      negative_infinity_default: f32::NEG_INFINITY,
+      double_inf_default: f64::INFINITY,
     }
   }
 }
@@ -1105,7 +1217,7 @@ impl Serialize for Monster<'_> {
   where
     S: Serializer,
   {
-    let mut s = serializer.serialize_struct("Monster", 54)?;
+    let mut s = serializer.serialize_struct("Monster", 62)?;
       if let Some(f) = self.pos() {
         s.serialize_field("pos", &f)?;
       } else {
@@ -1313,6 +1425,14 @@ impl Serialize for Monster<'_> {
       }
       s.serialize_field("long_enum_non_enum_default", &self.long_enum_non_enum_default())?;
       s.serialize_field("long_enum_normal_default", &self.long_enum_normal_default())?;
+      s.serialize_field("nan_default", &self.nan_default())?;
+      s.serialize_field("inf_default", &self.inf_default())?;
+      s.serialize_field("positive_inf_default", &self.positive_inf_default())?;
+      s.serialize_field("infinity_default", &self.infinity_default())?;
+      s.serialize_field("positive_infinity_default", &self.positive_infinity_default())?;
+      s.serialize_field("negative_inf_default", &self.negative_inf_default())?;
+      s.serialize_field("negative_infinity_default", &self.negative_infinity_default())?;
+      s.serialize_field("double_inf_default", &self.double_inf_default())?;
     s.end()
   }
 }
@@ -1535,6 +1655,38 @@ impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> {
     self.fbb_.push_slot::<LongEnum>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, long_enum_normal_default, LongEnum::LongOne);
   }
   #[inline]
+  pub fn add_nan_default(&mut self, nan_default: f32) {
+    self.fbb_.push_slot::<f32>(Monster::VT_NAN_DEFAULT, nan_default, f32::NAN);
+  }
+  #[inline]
+  pub fn add_inf_default(&mut self, inf_default: f32) {
+    self.fbb_.push_slot::<f32>(Monster::VT_INF_DEFAULT, inf_default, f32::INFINITY);
+  }
+  #[inline]
+  pub fn add_positive_inf_default(&mut self, positive_inf_default: f32) {
+    self.fbb_.push_slot::<f32>(Monster::VT_POSITIVE_INF_DEFAULT, positive_inf_default, f32::INFINITY);
+  }
+  #[inline]
+  pub fn add_infinity_default(&mut self, infinity_default: f32) {
+    self.fbb_.push_slot::<f32>(Monster::VT_INFINITY_DEFAULT, infinity_default, f32::INFINITY);
+  }
+  #[inline]
+  pub fn add_positive_infinity_default(&mut self, positive_infinity_default: f32) {
+    self.fbb_.push_slot::<f32>(Monster::VT_POSITIVE_INFINITY_DEFAULT, positive_infinity_default, f32::INFINITY);
+  }
+  #[inline]
+  pub fn add_negative_inf_default(&mut self, negative_inf_default: f32) {
+    self.fbb_.push_slot::<f32>(Monster::VT_NEGATIVE_INF_DEFAULT, negative_inf_default, f32::NEG_INFINITY);
+  }
+  #[inline]
+  pub fn add_negative_infinity_default(&mut self, negative_infinity_default: f32) {
+    self.fbb_.push_slot::<f32>(Monster::VT_NEGATIVE_INFINITY_DEFAULT, negative_infinity_default, f32::NEG_INFINITY);
+  }
+  #[inline]
+  pub fn add_double_inf_default(&mut self, double_inf_default: f64) {
+    self.fbb_.push_slot::<f64>(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, f64::INFINITY);
+  }
+  #[inline]
   pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MonsterBuilder<'a, 'b> {
     let start = _fbb.start_table();
     MonsterBuilder {
@@ -1684,6 +1836,14 @@ impl core::fmt::Debug for Monster<'_> {
       ds.field("native_inline", &self.native_inline());
       ds.field("long_enum_non_enum_default", &self.long_enum_non_enum_default());
       ds.field("long_enum_normal_default", &self.long_enum_normal_default());
+      ds.field("nan_default", &self.nan_default());
+      ds.field("inf_default", &self.inf_default());
+      ds.field("positive_inf_default", &self.positive_inf_default());
+      ds.field("infinity_default", &self.infinity_default());
+      ds.field("positive_infinity_default", &self.positive_infinity_default());
+      ds.field("negative_inf_default", &self.negative_inf_default());
+      ds.field("negative_infinity_default", &self.negative_infinity_default());
+      ds.field("double_inf_default", &self.double_inf_default());
       ds.finish()
   }
 }
@@ -1740,6 +1900,14 @@ pub struct MonsterT {
   pub native_inline: Option<TestT>,
   pub long_enum_non_enum_default: LongEnum,
   pub long_enum_normal_default: LongEnum,
+  pub nan_default: f32,
+  pub inf_default: f32,
+  pub positive_inf_default: f32,
+  pub infinity_default: f32,
+  pub positive_infinity_default: f32,
+  pub negative_inf_default: f32,
+  pub negative_infinity_default: f32,
+  pub double_inf_default: f64,
 }
 impl Default for MonsterT {
   fn default() -> Self {
@@ -1794,6 +1962,14 @@ impl Default for MonsterT {
       native_inline: None,
       long_enum_non_enum_default: Default::default(),
       long_enum_normal_default: LongEnum::LongOne,
+      nan_default: f32::NAN,
+      inf_default: f32::INFINITY,
+      positive_inf_default: f32::INFINITY,
+      infinity_default: f32::INFINITY,
+      positive_infinity_default: f32::INFINITY,
+      negative_inf_default: f32::NEG_INFINITY,
+      negative_infinity_default: f32::NEG_INFINITY,
+      double_inf_default: f64::INFINITY,
     }
   }
 }
@@ -1906,6 +2082,14 @@ impl MonsterT {
     let native_inline = native_inline_tmp.as_ref();
     let long_enum_non_enum_default = self.long_enum_non_enum_default;
     let long_enum_normal_default = self.long_enum_normal_default;
+    let nan_default = self.nan_default;
+    let inf_default = self.inf_default;
+    let positive_inf_default = self.positive_inf_default;
+    let infinity_default = self.infinity_default;
+    let positive_infinity_default = self.positive_infinity_default;
+    let negative_inf_default = self.negative_inf_default;
+    let negative_infinity_default = self.negative_infinity_default;
+    let double_inf_default = self.double_inf_default;
     Monster::create(_fbb, &MonsterArgs{
       pos,
       mana,
@@ -1960,6 +2144,14 @@ impl MonsterT {
       native_inline,
       long_enum_non_enum_default,
       long_enum_normal_default,
+      nan_default,
+      inf_default,
+      positive_inf_default,
+      infinity_default,
+      positive_infinity_default,
+      negative_inf_default,
+      negative_infinity_default,
+      double_inf_default,
     })
   }
 }

tests/monster_test_suffix/ext_only/monster_test_generated.hpp

@@ -1309,6 +1309,14 @@ struct MonsterT : public flatbuffers::NativeTable {
   MyGame::Example::Test native_inline{};
   MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0);
   MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne;
+  float nan_default = std::numeric_limits<float>::quiet_NaN();
+  float inf_default = std::numeric_limits<float>::infinity();
+  float positive_inf_default = std::numeric_limits<float>::infinity();
+  float infinity_default = std::numeric_limits<float>::infinity();
+  float positive_infinity_default = std::numeric_limits<float>::infinity();
+  float negative_inf_default = -std::numeric_limits<float>::infinity();
+  float negative_infinity_default = -std::numeric_limits<float>::infinity();
+  double double_inf_default = std::numeric_limits<double>::infinity();
   MonsterT() = default;
   MonsterT(const MonsterT &o);
   MonsterT(MonsterT&&) FLATBUFFERS_NOEXCEPT = default;
@@ -1375,7 +1383,15 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_SCALAR_KEY_SORTED_TABLES = 104,
     VT_NATIVE_INLINE = 106,
     VT_LONG_ENUM_NON_ENUM_DEFAULT = 108,
-    VT_LONG_ENUM_NORMAL_DEFAULT = 110
+    VT_LONG_ENUM_NORMAL_DEFAULT = 110,
+    VT_NAN_DEFAULT = 112,
+    VT_INF_DEFAULT = 114,
+    VT_POSITIVE_INF_DEFAULT = 116,
+    VT_INFINITY_DEFAULT = 118,
+    VT_POSITIVE_INFINITY_DEFAULT = 120,
+    VT_NEGATIVE_INF_DEFAULT = 122,
+    VT_NEGATIVE_INFINITY_DEFAULT = 124,
+    VT_DOUBLE_INF_DEFAULT = 126
   };
   const MyGame::Example::Vec3 *pos() const {
     return GetStruct<const MyGame::Example::Vec3 *>(VT_POS);
@@ -1732,6 +1748,54 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   bool mutate_long_enum_normal_default(MyGame::Example::LongEnum _long_enum_normal_default = static_cast<MyGame::Example::LongEnum>(2ULL)) {
     return SetField<uint64_t>(VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(_long_enum_normal_default), 2ULL);
   }
+  float nan_default() const {
+    return GetField<float>(VT_NAN_DEFAULT, std::numeric_limits<float>::quiet_NaN());
+  }
+  bool mutate_nan_default(float _nan_default = std::numeric_limits<float>::quiet_NaN()) {
+    return SetField<float>(VT_NAN_DEFAULT, _nan_default, std::numeric_limits<float>::quiet_NaN());
+  }
+  float inf_default() const {
+    return GetField<float>(VT_INF_DEFAULT, std::numeric_limits<float>::infinity());
+  }
+  bool mutate_inf_default(float _inf_default = std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_INF_DEFAULT, _inf_default, std::numeric_limits<float>::infinity());
+  }
+  float positive_inf_default() const {
+    return GetField<float>(VT_POSITIVE_INF_DEFAULT, std::numeric_limits<float>::infinity());
+  }
+  bool mutate_positive_inf_default(float _positive_inf_default = std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_POSITIVE_INF_DEFAULT, _positive_inf_default, std::numeric_limits<float>::infinity());
+  }
+  float infinity_default() const {
+    return GetField<float>(VT_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
+  }
+  bool mutate_infinity_default(float _infinity_default = std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_INFINITY_DEFAULT, _infinity_default, std::numeric_limits<float>::infinity());
+  }
+  float positive_infinity_default() const {
+    return GetField<float>(VT_POSITIVE_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
+  }
+  bool mutate_positive_infinity_default(float _positive_infinity_default = std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_POSITIVE_INFINITY_DEFAULT, _positive_infinity_default, std::numeric_limits<float>::infinity());
+  }
+  float negative_inf_default() const {
+    return GetField<float>(VT_NEGATIVE_INF_DEFAULT, -std::numeric_limits<float>::infinity());
+  }
+  bool mutate_negative_inf_default(float _negative_inf_default = -std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_NEGATIVE_INF_DEFAULT, _negative_inf_default, -std::numeric_limits<float>::infinity());
+  }
+  float negative_infinity_default() const {
+    return GetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, -std::numeric_limits<float>::infinity());
+  }
+  bool mutate_negative_infinity_default(float _negative_infinity_default = -std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, _negative_infinity_default, -std::numeric_limits<float>::infinity());
+  }
+  double double_inf_default() const {
+    return GetField<double>(VT_DOUBLE_INF_DEFAULT, std::numeric_limits<double>::infinity());
+  }
+  bool mutate_double_inf_default(double _double_inf_default = std::numeric_limits<double>::infinity()) {
+    return SetField<double>(VT_DOUBLE_INF_DEFAULT, _double_inf_default, std::numeric_limits<double>::infinity());
+  }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
@@ -1823,6 +1887,14 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
            VerifyField<MyGame::Example::Test>(verifier, VT_NATIVE_INLINE, 2) &&
            VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NON_ENUM_DEFAULT, 8) &&
            VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NORMAL_DEFAULT, 8) &&
+           VerifyField<float>(verifier, VT_NAN_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_INF_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_POSITIVE_INF_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_INFINITY_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_POSITIVE_INFINITY_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_NEGATIVE_INF_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_NEGATIVE_INFINITY_DEFAULT, 4) &&
+           VerifyField<double>(verifier, VT_DOUBLE_INF_DEFAULT, 8) &&
            verifier.EndTable();
   }
   MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -2017,6 +2089,30 @@ struct MonsterBuilder {
   void add_long_enum_normal_default(MyGame::Example::LongEnum long_enum_normal_default) {
     fbb_.AddElement<uint64_t>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(long_enum_normal_default), 2ULL);
   }
+  void add_nan_default(float nan_default) {
+    fbb_.AddElement<float>(Monster::VT_NAN_DEFAULT, nan_default, std::numeric_limits<float>::quiet_NaN());
+  }
+  void add_inf_default(float inf_default) {
+    fbb_.AddElement<float>(Monster::VT_INF_DEFAULT, inf_default, std::numeric_limits<float>::infinity());
+  }
+  void add_positive_inf_default(float positive_inf_default) {
+    fbb_.AddElement<float>(Monster::VT_POSITIVE_INF_DEFAULT, positive_inf_default, std::numeric_limits<float>::infinity());
+  }
+  void add_infinity_default(float infinity_default) {
+    fbb_.AddElement<float>(Monster::VT_INFINITY_DEFAULT, infinity_default, std::numeric_limits<float>::infinity());
+  }
+  void add_positive_infinity_default(float positive_infinity_default) {
+    fbb_.AddElement<float>(Monster::VT_POSITIVE_INFINITY_DEFAULT, positive_infinity_default, std::numeric_limits<float>::infinity());
+  }
+  void add_negative_inf_default(float negative_inf_default) {
+    fbb_.AddElement<float>(Monster::VT_NEGATIVE_INF_DEFAULT, negative_inf_default, -std::numeric_limits<float>::infinity());
+  }
+  void add_negative_infinity_default(float negative_infinity_default) {
+    fbb_.AddElement<float>(Monster::VT_NEGATIVE_INFINITY_DEFAULT, negative_infinity_default, -std::numeric_limits<float>::infinity());
+  }
+  void add_double_inf_default(double double_inf_default) {
+    fbb_.AddElement<double>(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, std::numeric_limits<double>::infinity());
+  }
   explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -2083,8 +2179,17 @@ inline flatbuffers::Offset<Monster> CreateMonster(
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables = 0,
     const MyGame::Example::Test *native_inline = nullptr,
     MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
-    MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne) {
+    MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne,
+    float nan_default = std::numeric_limits<float>::quiet_NaN(),
+    float inf_default = std::numeric_limits<float>::infinity(),
+    float positive_inf_default = std::numeric_limits<float>::infinity(),
+    float infinity_default = std::numeric_limits<float>::infinity(),
+    float positive_infinity_default = std::numeric_limits<float>::infinity(),
+    float negative_inf_default = -std::numeric_limits<float>::infinity(),
+    float negative_infinity_default = -std::numeric_limits<float>::infinity(),
+    double double_inf_default = std::numeric_limits<double>::infinity()) {
   MonsterBuilder builder_(_fbb);
+  builder_.add_double_inf_default(double_inf_default);
   builder_.add_long_enum_normal_default(long_enum_normal_default);
   builder_.add_long_enum_non_enum_default(long_enum_non_enum_default);
   builder_.add_non_owning_reference(non_owning_reference);
@@ -2094,6 +2199,13 @@ inline flatbuffers::Offset<Monster> CreateMonster(
   builder_.add_testhashs64_fnv1a(testhashs64_fnv1a);
   builder_.add_testhashu64_fnv1(testhashu64_fnv1);
   builder_.add_testhashs64_fnv1(testhashs64_fnv1);
+  builder_.add_negative_infinity_default(negative_infinity_default);
+  builder_.add_negative_inf_default(negative_inf_default);
+  builder_.add_positive_infinity_default(positive_infinity_default);
+  builder_.add_infinity_default(infinity_default);
+  builder_.add_positive_inf_default(positive_inf_default);
+  builder_.add_inf_default(inf_default);
+  builder_.add_nan_default(nan_default);
   builder_.add_native_inline(native_inline);
   builder_.add_scalar_key_sorted_tables(scalar_key_sorted_tables);
   builder_.add_testrequirednestedflatbuffer(testrequirednestedflatbuffer);
@@ -2195,7 +2307,15 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
     std::vector<flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables = nullptr,
     const MyGame::Example::Test *native_inline = nullptr,
     MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
-    MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne) {
+    MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne,
+    float nan_default = std::numeric_limits<float>::quiet_NaN(),
+    float inf_default = std::numeric_limits<float>::infinity(),
+    float positive_inf_default = std::numeric_limits<float>::infinity(),
+    float infinity_default = std::numeric_limits<float>::infinity(),
+    float positive_infinity_default = std::numeric_limits<float>::infinity(),
+    float negative_inf_default = -std::numeric_limits<float>::infinity(),
+    float negative_infinity_default = -std::numeric_limits<float>::infinity(),
+    double double_inf_default = std::numeric_limits<double>::infinity()) {
   auto name__ = name ? _fbb.CreateString(name) : 0;
   auto inventory__ = inventory ? _fbb.CreateVector<uint8_t>(*inventory) : 0;
   auto test4__ = test4 ? _fbb.CreateVectorOfStructs<MyGame::Example::Test>(*test4) : 0;
@@ -2271,7 +2391,15 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
       scalar_key_sorted_tables__,
       native_inline,
       long_enum_non_enum_default,
-      long_enum_normal_default);
+      long_enum_normal_default,
+      nan_default,
+      inf_default,
+      positive_inf_default,
+      infinity_default,
+      positive_infinity_default,
+      negative_inf_default,
+      negative_infinity_default,
+      double_inf_default);
 }
 
 flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -2767,7 +2895,15 @@ inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) {
       (lhs.scalar_key_sorted_tables.size() == rhs.scalar_key_sorted_tables.size() && std::equal(lhs.scalar_key_sorted_tables.cbegin(), lhs.scalar_key_sorted_tables.cend(), rhs.scalar_key_sorted_tables.cbegin(), [](flatbuffers::unique_ptr<MyGame::Example::StatT> const &a, flatbuffers::unique_ptr<MyGame::Example::StatT> const &b) { return (a == b) || (a && b && *a == *b); })) &&
       (lhs.native_inline == rhs.native_inline) &&
       (lhs.long_enum_non_enum_default == rhs.long_enum_non_enum_default) &&
-      (lhs.long_enum_normal_default == rhs.long_enum_normal_default);
+      (lhs.long_enum_normal_default == rhs.long_enum_normal_default) &&
+      (lhs.nan_default == rhs.nan_default) &&
+      (lhs.inf_default == rhs.inf_default) &&
+      (lhs.positive_inf_default == rhs.positive_inf_default) &&
+      (lhs.infinity_default == rhs.infinity_default) &&
+      (lhs.positive_infinity_default == rhs.positive_infinity_default) &&
+      (lhs.negative_inf_default == rhs.negative_inf_default) &&
+      (lhs.negative_infinity_default == rhs.negative_infinity_default) &&
+      (lhs.double_inf_default == rhs.double_inf_default);
 }
 
 inline bool operator!=(const MonsterT &lhs, const MonsterT &rhs) {
@@ -2820,7 +2956,15 @@ inline MonsterT::MonsterT(const MonsterT &o)
         testrequirednestedflatbuffer(o.testrequirednestedflatbuffer),
         native_inline(o.native_inline),
         long_enum_non_enum_default(o.long_enum_non_enum_default),
-        long_enum_normal_default(o.long_enum_normal_default) {
+        long_enum_normal_default(o.long_enum_normal_default),
+        nan_default(o.nan_default),
+        inf_default(o.inf_default),
+        positive_inf_default(o.positive_inf_default),
+        infinity_default(o.infinity_default),
+        positive_infinity_default(o.positive_infinity_default),
+        negative_inf_default(o.negative_inf_default),
+        negative_infinity_default(o.negative_infinity_default),
+        double_inf_default(o.double_inf_default) {
   testarrayoftables.reserve(o.testarrayoftables.size());
   for (const auto &testarrayoftables_ : o.testarrayoftables) { testarrayoftables.emplace_back((testarrayoftables_) ? new MyGame::Example::MonsterT(*testarrayoftables_) : nullptr); }
   vector_of_referrables.reserve(o.vector_of_referrables.size());
@@ -2884,6 +3028,14 @@ inline MonsterT &MonsterT::operator=(MonsterT o) FLATBUFFERS_NOEXCEPT {
   std::swap(native_inline, o.native_inline);
   std::swap(long_enum_non_enum_default, o.long_enum_non_enum_default);
   std::swap(long_enum_normal_default, o.long_enum_normal_default);
+  std::swap(nan_default, o.nan_default);
+  std::swap(inf_default, o.inf_default);
+  std::swap(positive_inf_default, o.positive_inf_default);
+  std::swap(infinity_default, o.infinity_default);
+  std::swap(positive_infinity_default, o.positive_infinity_default);
+  std::swap(negative_inf_default, o.negative_inf_default);
+  std::swap(negative_infinity_default, o.negative_infinity_default);
+  std::swap(double_inf_default, o.double_inf_default);
   return *this;
 }
 
@@ -2949,6 +3101,14 @@ inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function
   { auto _e = native_inline(); if (_e) _o->native_inline = *_e; }
   { auto _e = long_enum_non_enum_default(); _o->long_enum_non_enum_default = _e; }
   { auto _e = long_enum_normal_default(); _o->long_enum_normal_default = _e; }
+  { auto _e = nan_default(); _o->nan_default = _e; }
+  { auto _e = inf_default(); _o->inf_default = _e; }
+  { auto _e = positive_inf_default(); _o->positive_inf_default = _e; }
+  { auto _e = infinity_default(); _o->infinity_default = _e; }
+  { auto _e = positive_infinity_default(); _o->positive_infinity_default = _e; }
+  { auto _e = negative_inf_default(); _o->negative_inf_default = _e; }
+  { auto _e = negative_infinity_default(); _o->negative_infinity_default = _e; }
+  { auto _e = double_inf_default(); _o->double_inf_default = _e; }
 }
 
 inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -3012,6 +3172,14 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
   auto _native_inline = &_o->native_inline;
   auto _long_enum_non_enum_default = _o->long_enum_non_enum_default;
   auto _long_enum_normal_default = _o->long_enum_normal_default;
+  auto _nan_default = _o->nan_default;
+  auto _inf_default = _o->inf_default;
+  auto _positive_inf_default = _o->positive_inf_default;
+  auto _infinity_default = _o->infinity_default;
+  auto _positive_infinity_default = _o->positive_infinity_default;
+  auto _negative_inf_default = _o->negative_inf_default;
+  auto _negative_infinity_default = _o->negative_infinity_default;
+  auto _double_inf_default = _o->double_inf_default;
   return MyGame::Example::CreateMonster(
       _fbb,
       _pos,
@@ -3066,7 +3234,15 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
       _scalar_key_sorted_tables,
       _native_inline,
       _long_enum_non_enum_default,
-      _long_enum_normal_default);
+      _long_enum_normal_default,
+      _nan_default,
+      _inf_default,
+      _positive_inf_default,
+      _infinity_default,
+      _positive_infinity_default,
+      _negative_inf_default,
+      _negative_infinity_default,
+      _double_inf_default);
 }
 
 
@@ -3846,7 +4022,15 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
     { flatbuffers::ET_SEQUENCE, 1, 5 },
     { flatbuffers::ET_SEQUENCE, 0, 3 },
     { flatbuffers::ET_ULONG, 0, 12 },
-    { flatbuffers::ET_ULONG, 0, 12 }
+    { flatbuffers::ET_ULONG, 0, 12 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_DOUBLE, 0, -1 }
   };
   static const flatbuffers::TypeFunction type_refs[] = {
     MyGame::Example::Vec3TypeTable,
@@ -3917,10 +4101,18 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
     "scalar_key_sorted_tables",
     "native_inline",
     "long_enum_non_enum_default",
-    "long_enum_normal_default"
+    "long_enum_normal_default",
+    "nan_default",
+    "inf_default",
+    "positive_inf_default",
+    "infinity_default",
+    "positive_infinity_default",
+    "negative_inf_default",
+    "negative_infinity_default",
+    "double_inf_default"
   };
   static const flatbuffers::TypeTable tt = {
-    flatbuffers::ST_TABLE, 54, type_codes, type_refs, nullptr, nullptr, names
+    flatbuffers::ST_TABLE, 62, type_codes, type_refs, nullptr, nullptr, names
   };
   return &tt;
 }

tests/monster_test_suffix/filesuffix_only/monster_test_suffix.h

@@ -1309,6 +1309,14 @@ struct MonsterT : public flatbuffers::NativeTable {
   MyGame::Example::Test native_inline{};
   MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0);
   MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne;
+  float nan_default = std::numeric_limits<float>::quiet_NaN();
+  float inf_default = std::numeric_limits<float>::infinity();
+  float positive_inf_default = std::numeric_limits<float>::infinity();
+  float infinity_default = std::numeric_limits<float>::infinity();
+  float positive_infinity_default = std::numeric_limits<float>::infinity();
+  float negative_inf_default = -std::numeric_limits<float>::infinity();
+  float negative_infinity_default = -std::numeric_limits<float>::infinity();
+  double double_inf_default = std::numeric_limits<double>::infinity();
   MonsterT() = default;
   MonsterT(const MonsterT &o);
   MonsterT(MonsterT&&) FLATBUFFERS_NOEXCEPT = default;
@@ -1375,7 +1383,15 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_SCALAR_KEY_SORTED_TABLES = 104,
     VT_NATIVE_INLINE = 106,
     VT_LONG_ENUM_NON_ENUM_DEFAULT = 108,
-    VT_LONG_ENUM_NORMAL_DEFAULT = 110
+    VT_LONG_ENUM_NORMAL_DEFAULT = 110,
+    VT_NAN_DEFAULT = 112,
+    VT_INF_DEFAULT = 114,
+    VT_POSITIVE_INF_DEFAULT = 116,
+    VT_INFINITY_DEFAULT = 118,
+    VT_POSITIVE_INFINITY_DEFAULT = 120,
+    VT_NEGATIVE_INF_DEFAULT = 122,
+    VT_NEGATIVE_INFINITY_DEFAULT = 124,
+    VT_DOUBLE_INF_DEFAULT = 126
   };
   const MyGame::Example::Vec3 *pos() const {
     return GetStruct<const MyGame::Example::Vec3 *>(VT_POS);
@@ -1732,6 +1748,54 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   bool mutate_long_enum_normal_default(MyGame::Example::LongEnum _long_enum_normal_default = static_cast<MyGame::Example::LongEnum>(2ULL)) {
     return SetField<uint64_t>(VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(_long_enum_normal_default), 2ULL);
   }
+  float nan_default() const {
+    return GetField<float>(VT_NAN_DEFAULT, std::numeric_limits<float>::quiet_NaN());
+  }
+  bool mutate_nan_default(float _nan_default = std::numeric_limits<float>::quiet_NaN()) {
+    return SetField<float>(VT_NAN_DEFAULT, _nan_default, std::numeric_limits<float>::quiet_NaN());
+  }
+  float inf_default() const {
+    return GetField<float>(VT_INF_DEFAULT, std::numeric_limits<float>::infinity());
+  }
+  bool mutate_inf_default(float _inf_default = std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_INF_DEFAULT, _inf_default, std::numeric_limits<float>::infinity());
+  }
+  float positive_inf_default() const {
+    return GetField<float>(VT_POSITIVE_INF_DEFAULT, std::numeric_limits<float>::infinity());
+  }
+  bool mutate_positive_inf_default(float _positive_inf_default = std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_POSITIVE_INF_DEFAULT, _positive_inf_default, std::numeric_limits<float>::infinity());
+  }
+  float infinity_default() const {
+    return GetField<float>(VT_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
+  }
+  bool mutate_infinity_default(float _infinity_default = std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_INFINITY_DEFAULT, _infinity_default, std::numeric_limits<float>::infinity());
+  }
+  float positive_infinity_default() const {
+    return GetField<float>(VT_POSITIVE_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
+  }
+  bool mutate_positive_infinity_default(float _positive_infinity_default = std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_POSITIVE_INFINITY_DEFAULT, _positive_infinity_default, std::numeric_limits<float>::infinity());
+  }
+  float negative_inf_default() const {
+    return GetField<float>(VT_NEGATIVE_INF_DEFAULT, -std::numeric_limits<float>::infinity());
+  }
+  bool mutate_negative_inf_default(float _negative_inf_default = -std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_NEGATIVE_INF_DEFAULT, _negative_inf_default, -std::numeric_limits<float>::infinity());
+  }
+  float negative_infinity_default() const {
+    return GetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, -std::numeric_limits<float>::infinity());
+  }
+  bool mutate_negative_infinity_default(float _negative_infinity_default = -std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, _negative_infinity_default, -std::numeric_limits<float>::infinity());
+  }
+  double double_inf_default() const {
+    return GetField<double>(VT_DOUBLE_INF_DEFAULT, std::numeric_limits<double>::infinity());
+  }
+  bool mutate_double_inf_default(double _double_inf_default = std::numeric_limits<double>::infinity()) {
+    return SetField<double>(VT_DOUBLE_INF_DEFAULT, _double_inf_default, std::numeric_limits<double>::infinity());
+  }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
@@ -1823,6 +1887,14 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
            VerifyField<MyGame::Example::Test>(verifier, VT_NATIVE_INLINE, 2) &&
            VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NON_ENUM_DEFAULT, 8) &&
            VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NORMAL_DEFAULT, 8) &&
+           VerifyField<float>(verifier, VT_NAN_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_INF_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_POSITIVE_INF_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_INFINITY_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_POSITIVE_INFINITY_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_NEGATIVE_INF_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_NEGATIVE_INFINITY_DEFAULT, 4) &&
+           VerifyField<double>(verifier, VT_DOUBLE_INF_DEFAULT, 8) &&
            verifier.EndTable();
   }
   MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -2017,6 +2089,30 @@ struct MonsterBuilder {
   void add_long_enum_normal_default(MyGame::Example::LongEnum long_enum_normal_default) {
     fbb_.AddElement<uint64_t>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(long_enum_normal_default), 2ULL);
   }
+  void add_nan_default(float nan_default) {
+    fbb_.AddElement<float>(Monster::VT_NAN_DEFAULT, nan_default, std::numeric_limits<float>::quiet_NaN());
+  }
+  void add_inf_default(float inf_default) {
+    fbb_.AddElement<float>(Monster::VT_INF_DEFAULT, inf_default, std::numeric_limits<float>::infinity());
+  }
+  void add_positive_inf_default(float positive_inf_default) {
+    fbb_.AddElement<float>(Monster::VT_POSITIVE_INF_DEFAULT, positive_inf_default, std::numeric_limits<float>::infinity());
+  }
+  void add_infinity_default(float infinity_default) {
+    fbb_.AddElement<float>(Monster::VT_INFINITY_DEFAULT, infinity_default, std::numeric_limits<float>::infinity());
+  }
+  void add_positive_infinity_default(float positive_infinity_default) {
+    fbb_.AddElement<float>(Monster::VT_POSITIVE_INFINITY_DEFAULT, positive_infinity_default, std::numeric_limits<float>::infinity());
+  }
+  void add_negative_inf_default(float negative_inf_default) {
+    fbb_.AddElement<float>(Monster::VT_NEGATIVE_INF_DEFAULT, negative_inf_default, -std::numeric_limits<float>::infinity());
+  }
+  void add_negative_infinity_default(float negative_infinity_default) {
+    fbb_.AddElement<float>(Monster::VT_NEGATIVE_INFINITY_DEFAULT, negative_infinity_default, -std::numeric_limits<float>::infinity());
+  }
+  void add_double_inf_default(double double_inf_default) {
+    fbb_.AddElement<double>(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, std::numeric_limits<double>::infinity());
+  }
   explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -2083,8 +2179,17 @@ inline flatbuffers::Offset<Monster> CreateMonster(
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables = 0,
     const MyGame::Example::Test *native_inline = nullptr,
     MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
-    MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne) {
+    MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne,
+    float nan_default = std::numeric_limits<float>::quiet_NaN(),
+    float inf_default = std::numeric_limits<float>::infinity(),
+    float positive_inf_default = std::numeric_limits<float>::infinity(),
+    float infinity_default = std::numeric_limits<float>::infinity(),
+    float positive_infinity_default = std::numeric_limits<float>::infinity(),
+    float negative_inf_default = -std::numeric_limits<float>::infinity(),
+    float negative_infinity_default = -std::numeric_limits<float>::infinity(),
+    double double_inf_default = std::numeric_limits<double>::infinity()) {
   MonsterBuilder builder_(_fbb);
+  builder_.add_double_inf_default(double_inf_default);
   builder_.add_long_enum_normal_default(long_enum_normal_default);
   builder_.add_long_enum_non_enum_default(long_enum_non_enum_default);
   builder_.add_non_owning_reference(non_owning_reference);
@@ -2094,6 +2199,13 @@ inline flatbuffers::Offset<Monster> CreateMonster(
   builder_.add_testhashs64_fnv1a(testhashs64_fnv1a);
   builder_.add_testhashu64_fnv1(testhashu64_fnv1);
   builder_.add_testhashs64_fnv1(testhashs64_fnv1);
+  builder_.add_negative_infinity_default(negative_infinity_default);
+  builder_.add_negative_inf_default(negative_inf_default);
+  builder_.add_positive_infinity_default(positive_infinity_default);
+  builder_.add_infinity_default(infinity_default);
+  builder_.add_positive_inf_default(positive_inf_default);
+  builder_.add_inf_default(inf_default);
+  builder_.add_nan_default(nan_default);
   builder_.add_native_inline(native_inline);
   builder_.add_scalar_key_sorted_tables(scalar_key_sorted_tables);
   builder_.add_testrequirednestedflatbuffer(testrequirednestedflatbuffer);
@@ -2195,7 +2307,15 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
     std::vector<flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables = nullptr,
     const MyGame::Example::Test *native_inline = nullptr,
     MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
-    MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne) {
+    MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne,
+    float nan_default = std::numeric_limits<float>::quiet_NaN(),
+    float inf_default = std::numeric_limits<float>::infinity(),
+    float positive_inf_default = std::numeric_limits<float>::infinity(),
+    float infinity_default = std::numeric_limits<float>::infinity(),
+    float positive_infinity_default = std::numeric_limits<float>::infinity(),
+    float negative_inf_default = -std::numeric_limits<float>::infinity(),
+    float negative_infinity_default = -std::numeric_limits<float>::infinity(),
+    double double_inf_default = std::numeric_limits<double>::infinity()) {
   auto name__ = name ? _fbb.CreateString(name) : 0;
   auto inventory__ = inventory ? _fbb.CreateVector<uint8_t>(*inventory) : 0;
   auto test4__ = test4 ? _fbb.CreateVectorOfStructs<MyGame::Example::Test>(*test4) : 0;
@@ -2271,7 +2391,15 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
       scalar_key_sorted_tables__,
       native_inline,
       long_enum_non_enum_default,
-      long_enum_normal_default);
+      long_enum_normal_default,
+      nan_default,
+      inf_default,
+      positive_inf_default,
+      infinity_default,
+      positive_infinity_default,
+      negative_inf_default,
+      negative_infinity_default,
+      double_inf_default);
 }
 
 flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -2767,7 +2895,15 @@ inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) {
       (lhs.scalar_key_sorted_tables.size() == rhs.scalar_key_sorted_tables.size() && std::equal(lhs.scalar_key_sorted_tables.cbegin(), lhs.scalar_key_sorted_tables.cend(), rhs.scalar_key_sorted_tables.cbegin(), [](flatbuffers::unique_ptr<MyGame::Example::StatT> const &a, flatbuffers::unique_ptr<MyGame::Example::StatT> const &b) { return (a == b) || (a && b && *a == *b); })) &&
       (lhs.native_inline == rhs.native_inline) &&
       (lhs.long_enum_non_enum_default == rhs.long_enum_non_enum_default) &&
-      (lhs.long_enum_normal_default == rhs.long_enum_normal_default);
+      (lhs.long_enum_normal_default == rhs.long_enum_normal_default) &&
+      (lhs.nan_default == rhs.nan_default) &&
+      (lhs.inf_default == rhs.inf_default) &&
+      (lhs.positive_inf_default == rhs.positive_inf_default) &&
+      (lhs.infinity_default == rhs.infinity_default) &&
+      (lhs.positive_infinity_default == rhs.positive_infinity_default) &&
+      (lhs.negative_inf_default == rhs.negative_inf_default) &&
+      (lhs.negative_infinity_default == rhs.negative_infinity_default) &&
+      (lhs.double_inf_default == rhs.double_inf_default);
 }
 
 inline bool operator!=(const MonsterT &lhs, const MonsterT &rhs) {
@@ -2820,7 +2956,15 @@ inline MonsterT::MonsterT(const MonsterT &o)
         testrequirednestedflatbuffer(o.testrequirednestedflatbuffer),
         native_inline(o.native_inline),
         long_enum_non_enum_default(o.long_enum_non_enum_default),
-        long_enum_normal_default(o.long_enum_normal_default) {
+        long_enum_normal_default(o.long_enum_normal_default),
+        nan_default(o.nan_default),
+        inf_default(o.inf_default),
+        positive_inf_default(o.positive_inf_default),
+        infinity_default(o.infinity_default),
+        positive_infinity_default(o.positive_infinity_default),
+        negative_inf_default(o.negative_inf_default),
+        negative_infinity_default(o.negative_infinity_default),
+        double_inf_default(o.double_inf_default) {
   testarrayoftables.reserve(o.testarrayoftables.size());
   for (const auto &testarrayoftables_ : o.testarrayoftables) { testarrayoftables.emplace_back((testarrayoftables_) ? new MyGame::Example::MonsterT(*testarrayoftables_) : nullptr); }
   vector_of_referrables.reserve(o.vector_of_referrables.size());
@@ -2884,6 +3028,14 @@ inline MonsterT &MonsterT::operator=(MonsterT o) FLATBUFFERS_NOEXCEPT {
   std::swap(native_inline, o.native_inline);
   std::swap(long_enum_non_enum_default, o.long_enum_non_enum_default);
   std::swap(long_enum_normal_default, o.long_enum_normal_default);
+  std::swap(nan_default, o.nan_default);
+  std::swap(inf_default, o.inf_default);
+  std::swap(positive_inf_default, o.positive_inf_default);
+  std::swap(infinity_default, o.infinity_default);
+  std::swap(positive_infinity_default, o.positive_infinity_default);
+  std::swap(negative_inf_default, o.negative_inf_default);
+  std::swap(negative_infinity_default, o.negative_infinity_default);
+  std::swap(double_inf_default, o.double_inf_default);
   return *this;
 }
 
@@ -2949,6 +3101,14 @@ inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function
   { auto _e = native_inline(); if (_e) _o->native_inline = *_e; }
   { auto _e = long_enum_non_enum_default(); _o->long_enum_non_enum_default = _e; }
   { auto _e = long_enum_normal_default(); _o->long_enum_normal_default = _e; }
+  { auto _e = nan_default(); _o->nan_default = _e; }
+  { auto _e = inf_default(); _o->inf_default = _e; }
+  { auto _e = positive_inf_default(); _o->positive_inf_default = _e; }
+  { auto _e = infinity_default(); _o->infinity_default = _e; }
+  { auto _e = positive_infinity_default(); _o->positive_infinity_default = _e; }
+  { auto _e = negative_inf_default(); _o->negative_inf_default = _e; }
+  { auto _e = negative_infinity_default(); _o->negative_infinity_default = _e; }
+  { auto _e = double_inf_default(); _o->double_inf_default = _e; }
 }
 
 inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -3012,6 +3172,14 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
   auto _native_inline = &_o->native_inline;
   auto _long_enum_non_enum_default = _o->long_enum_non_enum_default;
   auto _long_enum_normal_default = _o->long_enum_normal_default;
+  auto _nan_default = _o->nan_default;
+  auto _inf_default = _o->inf_default;
+  auto _positive_inf_default = _o->positive_inf_default;
+  auto _infinity_default = _o->infinity_default;
+  auto _positive_infinity_default = _o->positive_infinity_default;
+  auto _negative_inf_default = _o->negative_inf_default;
+  auto _negative_infinity_default = _o->negative_infinity_default;
+  auto _double_inf_default = _o->double_inf_default;
   return MyGame::Example::CreateMonster(
       _fbb,
       _pos,
@@ -3066,7 +3234,15 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
       _scalar_key_sorted_tables,
       _native_inline,
       _long_enum_non_enum_default,
-      _long_enum_normal_default);
+      _long_enum_normal_default,
+      _nan_default,
+      _inf_default,
+      _positive_inf_default,
+      _infinity_default,
+      _positive_infinity_default,
+      _negative_inf_default,
+      _negative_infinity_default,
+      _double_inf_default);
 }
 
 
@@ -3846,7 +4022,15 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
     { flatbuffers::ET_SEQUENCE, 1, 5 },
     { flatbuffers::ET_SEQUENCE, 0, 3 },
     { flatbuffers::ET_ULONG, 0, 12 },
-    { flatbuffers::ET_ULONG, 0, 12 }
+    { flatbuffers::ET_ULONG, 0, 12 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_DOUBLE, 0, -1 }
   };
   static const flatbuffers::TypeFunction type_refs[] = {
     MyGame::Example::Vec3TypeTable,
@@ -3917,10 +4101,18 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
     "scalar_key_sorted_tables",
     "native_inline",
     "long_enum_non_enum_default",
-    "long_enum_normal_default"
+    "long_enum_normal_default",
+    "nan_default",
+    "inf_default",
+    "positive_inf_default",
+    "infinity_default",
+    "positive_infinity_default",
+    "negative_inf_default",
+    "negative_infinity_default",
+    "double_inf_default"
   };
   static const flatbuffers::TypeTable tt = {
-    flatbuffers::ST_TABLE, 54, type_codes, type_refs, nullptr, nullptr, names
+    flatbuffers::ST_TABLE, 62, type_codes, type_refs, nullptr, nullptr, names
   };
   return &tt;
 }

tests/monster_test_suffix/monster_test_suffix.hpp

@@ -1309,6 +1309,14 @@ struct MonsterT : public flatbuffers::NativeTable {
   MyGame::Example::Test native_inline{};
   MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0);
   MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne;
+  float nan_default = std::numeric_limits<float>::quiet_NaN();
+  float inf_default = std::numeric_limits<float>::infinity();
+  float positive_inf_default = std::numeric_limits<float>::infinity();
+  float infinity_default = std::numeric_limits<float>::infinity();
+  float positive_infinity_default = std::numeric_limits<float>::infinity();
+  float negative_inf_default = -std::numeric_limits<float>::infinity();
+  float negative_infinity_default = -std::numeric_limits<float>::infinity();
+  double double_inf_default = std::numeric_limits<double>::infinity();
   MonsterT() = default;
   MonsterT(const MonsterT &o);
   MonsterT(MonsterT&&) FLATBUFFERS_NOEXCEPT = default;
@@ -1375,7 +1383,15 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
     VT_SCALAR_KEY_SORTED_TABLES = 104,
     VT_NATIVE_INLINE = 106,
     VT_LONG_ENUM_NON_ENUM_DEFAULT = 108,
-    VT_LONG_ENUM_NORMAL_DEFAULT = 110
+    VT_LONG_ENUM_NORMAL_DEFAULT = 110,
+    VT_NAN_DEFAULT = 112,
+    VT_INF_DEFAULT = 114,
+    VT_POSITIVE_INF_DEFAULT = 116,
+    VT_INFINITY_DEFAULT = 118,
+    VT_POSITIVE_INFINITY_DEFAULT = 120,
+    VT_NEGATIVE_INF_DEFAULT = 122,
+    VT_NEGATIVE_INFINITY_DEFAULT = 124,
+    VT_DOUBLE_INF_DEFAULT = 126
   };
   const MyGame::Example::Vec3 *pos() const {
     return GetStruct<const MyGame::Example::Vec3 *>(VT_POS);
@@ -1732,6 +1748,54 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   bool mutate_long_enum_normal_default(MyGame::Example::LongEnum _long_enum_normal_default = static_cast<MyGame::Example::LongEnum>(2ULL)) {
     return SetField<uint64_t>(VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(_long_enum_normal_default), 2ULL);
   }
+  float nan_default() const {
+    return GetField<float>(VT_NAN_DEFAULT, std::numeric_limits<float>::quiet_NaN());
+  }
+  bool mutate_nan_default(float _nan_default = std::numeric_limits<float>::quiet_NaN()) {
+    return SetField<float>(VT_NAN_DEFAULT, _nan_default, std::numeric_limits<float>::quiet_NaN());
+  }
+  float inf_default() const {
+    return GetField<float>(VT_INF_DEFAULT, std::numeric_limits<float>::infinity());
+  }
+  bool mutate_inf_default(float _inf_default = std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_INF_DEFAULT, _inf_default, std::numeric_limits<float>::infinity());
+  }
+  float positive_inf_default() const {
+    return GetField<float>(VT_POSITIVE_INF_DEFAULT, std::numeric_limits<float>::infinity());
+  }
+  bool mutate_positive_inf_default(float _positive_inf_default = std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_POSITIVE_INF_DEFAULT, _positive_inf_default, std::numeric_limits<float>::infinity());
+  }
+  float infinity_default() const {
+    return GetField<float>(VT_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
+  }
+  bool mutate_infinity_default(float _infinity_default = std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_INFINITY_DEFAULT, _infinity_default, std::numeric_limits<float>::infinity());
+  }
+  float positive_infinity_default() const {
+    return GetField<float>(VT_POSITIVE_INFINITY_DEFAULT, std::numeric_limits<float>::infinity());
+  }
+  bool mutate_positive_infinity_default(float _positive_infinity_default = std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_POSITIVE_INFINITY_DEFAULT, _positive_infinity_default, std::numeric_limits<float>::infinity());
+  }
+  float negative_inf_default() const {
+    return GetField<float>(VT_NEGATIVE_INF_DEFAULT, -std::numeric_limits<float>::infinity());
+  }
+  bool mutate_negative_inf_default(float _negative_inf_default = -std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_NEGATIVE_INF_DEFAULT, _negative_inf_default, -std::numeric_limits<float>::infinity());
+  }
+  float negative_infinity_default() const {
+    return GetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, -std::numeric_limits<float>::infinity());
+  }
+  bool mutate_negative_infinity_default(float _negative_infinity_default = -std::numeric_limits<float>::infinity()) {
+    return SetField<float>(VT_NEGATIVE_INFINITY_DEFAULT, _negative_infinity_default, -std::numeric_limits<float>::infinity());
+  }
+  double double_inf_default() const {
+    return GetField<double>(VT_DOUBLE_INF_DEFAULT, std::numeric_limits<double>::infinity());
+  }
+  bool mutate_double_inf_default(double _double_inf_default = std::numeric_limits<double>::infinity()) {
+    return SetField<double>(VT_DOUBLE_INF_DEFAULT, _double_inf_default, std::numeric_limits<double>::infinity());
+  }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<MyGame::Example::Vec3>(verifier, VT_POS, 8) &&
@@ -1823,6 +1887,14 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
            VerifyField<MyGame::Example::Test>(verifier, VT_NATIVE_INLINE, 2) &&
            VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NON_ENUM_DEFAULT, 8) &&
            VerifyField<uint64_t>(verifier, VT_LONG_ENUM_NORMAL_DEFAULT, 8) &&
+           VerifyField<float>(verifier, VT_NAN_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_INF_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_POSITIVE_INF_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_INFINITY_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_POSITIVE_INFINITY_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_NEGATIVE_INF_DEFAULT, 4) &&
+           VerifyField<float>(verifier, VT_NEGATIVE_INFINITY_DEFAULT, 4) &&
+           VerifyField<double>(verifier, VT_DOUBLE_INF_DEFAULT, 8) &&
            verifier.EndTable();
   }
   MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
@@ -2017,6 +2089,30 @@ struct MonsterBuilder {
   void add_long_enum_normal_default(MyGame::Example::LongEnum long_enum_normal_default) {
     fbb_.AddElement<uint64_t>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, static_cast<uint64_t>(long_enum_normal_default), 2ULL);
   }
+  void add_nan_default(float nan_default) {
+    fbb_.AddElement<float>(Monster::VT_NAN_DEFAULT, nan_default, std::numeric_limits<float>::quiet_NaN());
+  }
+  void add_inf_default(float inf_default) {
+    fbb_.AddElement<float>(Monster::VT_INF_DEFAULT, inf_default, std::numeric_limits<float>::infinity());
+  }
+  void add_positive_inf_default(float positive_inf_default) {
+    fbb_.AddElement<float>(Monster::VT_POSITIVE_INF_DEFAULT, positive_inf_default, std::numeric_limits<float>::infinity());
+  }
+  void add_infinity_default(float infinity_default) {
+    fbb_.AddElement<float>(Monster::VT_INFINITY_DEFAULT, infinity_default, std::numeric_limits<float>::infinity());
+  }
+  void add_positive_infinity_default(float positive_infinity_default) {
+    fbb_.AddElement<float>(Monster::VT_POSITIVE_INFINITY_DEFAULT, positive_infinity_default, std::numeric_limits<float>::infinity());
+  }
+  void add_negative_inf_default(float negative_inf_default) {
+    fbb_.AddElement<float>(Monster::VT_NEGATIVE_INF_DEFAULT, negative_inf_default, -std::numeric_limits<float>::infinity());
+  }
+  void add_negative_infinity_default(float negative_infinity_default) {
+    fbb_.AddElement<float>(Monster::VT_NEGATIVE_INFINITY_DEFAULT, negative_infinity_default, -std::numeric_limits<float>::infinity());
+  }
+  void add_double_inf_default(double double_inf_default) {
+    fbb_.AddElement<double>(Monster::VT_DOUBLE_INF_DEFAULT, double_inf_default, std::numeric_limits<double>::infinity());
+  }
   explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
         : fbb_(_fbb) {
     start_ = fbb_.StartTable();
@@ -2083,8 +2179,17 @@ inline flatbuffers::Offset<Monster> CreateMonster(
     flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<MyGame::Example::Stat>>> scalar_key_sorted_tables = 0,
     const MyGame::Example::Test *native_inline = nullptr,
     MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
-    MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne) {
+    MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne,
+    float nan_default = std::numeric_limits<float>::quiet_NaN(),
+    float inf_default = std::numeric_limits<float>::infinity(),
+    float positive_inf_default = std::numeric_limits<float>::infinity(),
+    float infinity_default = std::numeric_limits<float>::infinity(),
+    float positive_infinity_default = std::numeric_limits<float>::infinity(),
+    float negative_inf_default = -std::numeric_limits<float>::infinity(),
+    float negative_infinity_default = -std::numeric_limits<float>::infinity(),
+    double double_inf_default = std::numeric_limits<double>::infinity()) {
   MonsterBuilder builder_(_fbb);
+  builder_.add_double_inf_default(double_inf_default);
   builder_.add_long_enum_normal_default(long_enum_normal_default);
   builder_.add_long_enum_non_enum_default(long_enum_non_enum_default);
   builder_.add_non_owning_reference(non_owning_reference);
@@ -2094,6 +2199,13 @@ inline flatbuffers::Offset<Monster> CreateMonster(
   builder_.add_testhashs64_fnv1a(testhashs64_fnv1a);
   builder_.add_testhashu64_fnv1(testhashu64_fnv1);
   builder_.add_testhashs64_fnv1(testhashs64_fnv1);
+  builder_.add_negative_infinity_default(negative_infinity_default);
+  builder_.add_negative_inf_default(negative_inf_default);
+  builder_.add_positive_infinity_default(positive_infinity_default);
+  builder_.add_infinity_default(infinity_default);
+  builder_.add_positive_inf_default(positive_inf_default);
+  builder_.add_inf_default(inf_default);
+  builder_.add_nan_default(nan_default);
   builder_.add_native_inline(native_inline);
   builder_.add_scalar_key_sorted_tables(scalar_key_sorted_tables);
   builder_.add_testrequirednestedflatbuffer(testrequirednestedflatbuffer);
@@ -2195,7 +2307,15 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
     std::vector<flatbuffers::Offset<MyGame::Example::Stat>> *scalar_key_sorted_tables = nullptr,
     const MyGame::Example::Test *native_inline = nullptr,
     MyGame::Example::LongEnum long_enum_non_enum_default = static_cast<MyGame::Example::LongEnum>(0),
-    MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne) {
+    MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne,
+    float nan_default = std::numeric_limits<float>::quiet_NaN(),
+    float inf_default = std::numeric_limits<float>::infinity(),
+    float positive_inf_default = std::numeric_limits<float>::infinity(),
+    float infinity_default = std::numeric_limits<float>::infinity(),
+    float positive_infinity_default = std::numeric_limits<float>::infinity(),
+    float negative_inf_default = -std::numeric_limits<float>::infinity(),
+    float negative_infinity_default = -std::numeric_limits<float>::infinity(),
+    double double_inf_default = std::numeric_limits<double>::infinity()) {
   auto name__ = name ? _fbb.CreateString(name) : 0;
   auto inventory__ = inventory ? _fbb.CreateVector<uint8_t>(*inventory) : 0;
   auto test4__ = test4 ? _fbb.CreateVectorOfStructs<MyGame::Example::Test>(*test4) : 0;
@@ -2271,7 +2391,15 @@ inline flatbuffers::Offset<Monster> CreateMonsterDirect(
       scalar_key_sorted_tables__,
       native_inline,
       long_enum_non_enum_default,
-      long_enum_normal_default);
+      long_enum_normal_default,
+      nan_default,
+      inf_default,
+      positive_inf_default,
+      infinity_default,
+      positive_infinity_default,
+      negative_inf_default,
+      negative_infinity_default,
+      double_inf_default);
 }
 
 flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
@@ -2767,7 +2895,15 @@ inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) {
       (lhs.scalar_key_sorted_tables.size() == rhs.scalar_key_sorted_tables.size() && std::equal(lhs.scalar_key_sorted_tables.cbegin(), lhs.scalar_key_sorted_tables.cend(), rhs.scalar_key_sorted_tables.cbegin(), [](flatbuffers::unique_ptr<MyGame::Example::StatT> const &a, flatbuffers::unique_ptr<MyGame::Example::StatT> const &b) { return (a == b) || (a && b && *a == *b); })) &&
       (lhs.native_inline == rhs.native_inline) &&
       (lhs.long_enum_non_enum_default == rhs.long_enum_non_enum_default) &&
-      (lhs.long_enum_normal_default == rhs.long_enum_normal_default);
+      (lhs.long_enum_normal_default == rhs.long_enum_normal_default) &&
+      (lhs.nan_default == rhs.nan_default) &&
+      (lhs.inf_default == rhs.inf_default) &&
+      (lhs.positive_inf_default == rhs.positive_inf_default) &&
+      (lhs.infinity_default == rhs.infinity_default) &&
+      (lhs.positive_infinity_default == rhs.positive_infinity_default) &&
+      (lhs.negative_inf_default == rhs.negative_inf_default) &&
+      (lhs.negative_infinity_default == rhs.negative_infinity_default) &&
+      (lhs.double_inf_default == rhs.double_inf_default);
 }
 
 inline bool operator!=(const MonsterT &lhs, const MonsterT &rhs) {
@@ -2820,7 +2956,15 @@ inline MonsterT::MonsterT(const MonsterT &o)
         testrequirednestedflatbuffer(o.testrequirednestedflatbuffer),
         native_inline(o.native_inline),
         long_enum_non_enum_default(o.long_enum_non_enum_default),
-        long_enum_normal_default(o.long_enum_normal_default) {
+        long_enum_normal_default(o.long_enum_normal_default),
+        nan_default(o.nan_default),
+        inf_default(o.inf_default),
+        positive_inf_default(o.positive_inf_default),
+        infinity_default(o.infinity_default),
+        positive_infinity_default(o.positive_infinity_default),
+        negative_inf_default(o.negative_inf_default),
+        negative_infinity_default(o.negative_infinity_default),
+        double_inf_default(o.double_inf_default) {
   testarrayoftables.reserve(o.testarrayoftables.size());
   for (const auto &testarrayoftables_ : o.testarrayoftables) { testarrayoftables.emplace_back((testarrayoftables_) ? new MyGame::Example::MonsterT(*testarrayoftables_) : nullptr); }
   vector_of_referrables.reserve(o.vector_of_referrables.size());
@@ -2884,6 +3028,14 @@ inline MonsterT &MonsterT::operator=(MonsterT o) FLATBUFFERS_NOEXCEPT {
   std::swap(native_inline, o.native_inline);
   std::swap(long_enum_non_enum_default, o.long_enum_non_enum_default);
   std::swap(long_enum_normal_default, o.long_enum_normal_default);
+  std::swap(nan_default, o.nan_default);
+  std::swap(inf_default, o.inf_default);
+  std::swap(positive_inf_default, o.positive_inf_default);
+  std::swap(infinity_default, o.infinity_default);
+  std::swap(positive_infinity_default, o.positive_infinity_default);
+  std::swap(negative_inf_default, o.negative_inf_default);
+  std::swap(negative_infinity_default, o.negative_infinity_default);
+  std::swap(double_inf_default, o.double_inf_default);
   return *this;
 }
 
@@ -2949,6 +3101,14 @@ inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function
   { auto _e = native_inline(); if (_e) _o->native_inline = *_e; }
   { auto _e = long_enum_non_enum_default(); _o->long_enum_non_enum_default = _e; }
   { auto _e = long_enum_normal_default(); _o->long_enum_normal_default = _e; }
+  { auto _e = nan_default(); _o->nan_default = _e; }
+  { auto _e = inf_default(); _o->inf_default = _e; }
+  { auto _e = positive_inf_default(); _o->positive_inf_default = _e; }
+  { auto _e = infinity_default(); _o->infinity_default = _e; }
+  { auto _e = positive_infinity_default(); _o->positive_infinity_default = _e; }
+  { auto _e = negative_inf_default(); _o->negative_inf_default = _e; }
+  { auto _e = negative_infinity_default(); _o->negative_infinity_default = _e; }
+  { auto _e = double_inf_default(); _o->double_inf_default = _e; }
 }
 
 inline flatbuffers::Offset<Monster> Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
@@ -3012,6 +3172,14 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
   auto _native_inline = &_o->native_inline;
   auto _long_enum_non_enum_default = _o->long_enum_non_enum_default;
   auto _long_enum_normal_default = _o->long_enum_normal_default;
+  auto _nan_default = _o->nan_default;
+  auto _inf_default = _o->inf_default;
+  auto _positive_inf_default = _o->positive_inf_default;
+  auto _infinity_default = _o->infinity_default;
+  auto _positive_infinity_default = _o->positive_infinity_default;
+  auto _negative_inf_default = _o->negative_inf_default;
+  auto _negative_infinity_default = _o->negative_infinity_default;
+  auto _double_inf_default = _o->double_inf_default;
   return MyGame::Example::CreateMonster(
       _fbb,
       _pos,
@@ -3066,7 +3234,15 @@ inline flatbuffers::Offset<Monster> CreateMonster(flatbuffers::FlatBufferBuilder
       _scalar_key_sorted_tables,
       _native_inline,
       _long_enum_non_enum_default,
-      _long_enum_normal_default);
+      _long_enum_normal_default,
+      _nan_default,
+      _inf_default,
+      _positive_inf_default,
+      _infinity_default,
+      _positive_infinity_default,
+      _negative_inf_default,
+      _negative_infinity_default,
+      _double_inf_default);
 }
 
 
@@ -3846,7 +4022,15 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
     { flatbuffers::ET_SEQUENCE, 1, 5 },
     { flatbuffers::ET_SEQUENCE, 0, 3 },
     { flatbuffers::ET_ULONG, 0, 12 },
-    { flatbuffers::ET_ULONG, 0, 12 }
+    { flatbuffers::ET_ULONG, 0, 12 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_FLOAT, 0, -1 },
+    { flatbuffers::ET_DOUBLE, 0, -1 }
   };
   static const flatbuffers::TypeFunction type_refs[] = {
     MyGame::Example::Vec3TypeTable,
@@ -3917,10 +4101,18 @@ inline const flatbuffers::TypeTable *MonsterTypeTable() {
     "scalar_key_sorted_tables",
     "native_inline",
     "long_enum_non_enum_default",
-    "long_enum_normal_default"
+    "long_enum_normal_default",
+    "nan_default",
+    "inf_default",
+    "positive_inf_default",
+    "infinity_default",
+    "positive_infinity_default",
+    "negative_inf_default",
+    "negative_infinity_default",
+    "double_inf_default"
   };
   static const flatbuffers::TypeTable tt = {
-    flatbuffers::ST_TABLE, 54, type_codes, type_refs, nullptr, nullptr, names
+    flatbuffers::ST_TABLE, 62, type_codes, type_refs, nullptr, nullptr, names
   };
   return &tt;
 }

tests/reflection_test.cpp

@@ -266,10 +266,14 @@ void MiniReflectFlatBuffersTest(uint8_t *flatbuf) {
       "}, "
       "{ name: \"Wilma\" } ], "
       // TODO(wvo): should really print this nested buffer correctly.
-      "testnestedflatbuffer: [ 20, 0, 0, 0, 77, 79, 78, 83, 12, 0, 12, 0, 0, "
+      "testnestedflatbuffer: [ 124, 0, 0, 0, 77, 79, 78, 83, 0, 0, 114, 0, 16, "
-      "0, "
+      "0, 0, 0, 4, 0, 6, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "
-      "4, 0, 6, 0, 8, 0, 12, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 13, 0, 0, 0, 78, "
+      "0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "
-      "101, 115, 116, 101, 100, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0 ], "
+      "0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "
+      "0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "
+      "0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 114, 0, 0, 0, 0, 0, 0, 0, "
+      "8, 0, 0, 0, 0, 0, 192, 127, 13, 0, 0, 0, 78, 101, 115, 116, 101, 100, "
+      "77, 111, 110, 115, 116, 101, 114, 0, 0, 0 ], "
       "testarrayofstring2: [ \"jane\", \"mary\" ], "
       "testarrayofsortedstruct: [ { id: 0, distance: 0 }, "
       "{ id: 2, distance: 20 }, { id: 3, distance: 30 }, "
@@ -277,7 +281,8 @@ void MiniReflectFlatBuffersTest(uint8_t *flatbuf) {
       "flex: [ 210, 4, 5, 2 ], "
       "test5: [ { a: 10, b: 20 }, { a: 30, b: 40 } ], "
       "vector_of_enums: [ Blue, Green ], "
-      "scalar_key_sorted_tables: [ { id: \"miss\" } ] "
+      "scalar_key_sorted_tables: [ { id: \"miss\" } ], "
+      "nan_default: nan "
       "}");
 
   Test test(16, 32);
@@ -317,4 +322,4 @@ void MiniReflectFixedLengthArrayTest() {
 }
 
 }  // namespace tests
-}  // namespace flatbuffers
+}  // namespace flatbuffers

tests/rust_usage_test/tests/integration_test.rs

@@ -152,8 +152,10 @@ fn object_api_defaults() {
             b: 0
         }
     });
+    let mut default_without_nan = MonsterT::default();
+    default_without_nan.nan_default = 0.0;
     assert_eq!(
-        MonsterT::default(),
+        default_without_nan,
         MonsterT {
             pos: None,
             hp: 100,
@@ -205,6 +207,14 @@ fn object_api_defaults() {
             native_inline: None,
             long_enum_non_enum_default: Default::default(),
             long_enum_normal_default: LongEnum::LongOne,
+            nan_default: 0.0,
+            inf_default: f32::INFINITY,
+            positive_inf_default: f32::INFINITY,
+            infinity_default: f32::INFINITY,
+            positive_infinity_default: f32::INFINITY,
+            negative_inf_default: f32::NEG_INFINITY,
+            negative_infinity_default: f32::NEG_INFINITY,
+            double_inf_default: f64::INFINITY,
         }
     );
 }
@@ -467,7 +477,7 @@ fn verifier_apparent_size_too_large() {
     });
     b.finish(m, None);
     let data = b.finished_data();
-    assert!(data.len() < 5100);  // est 4000 for the vector + 1000 for the string + 100 overhead.
+    assert!(data.len() < 5200);  // est 4000 for the vector + 1000 for the string + 200 overhead.
     let mut opts = flatbuffers::VerifierOptions::default();
     opts.max_apparent_size = 1_000_000;
 
@@ -1774,7 +1784,10 @@ mod write_and_read_examples {
             vector_of_enums: None, signed_enum: None, \
             testrequirednestedflatbuffer: None, scalar_key_sorted_tables: None, \
             native_inline: None, long_enum_non_enum_default: (empty), \
-            long_enum_normal_default: LongOne }, \
+            long_enum_normal_default: LongOne, nan_default: NaN, inf_default: \
+            inf, positive_inf_default: inf, infinity_default: inf, \
+            positive_infinity_default: inf, negative_inf_default: -inf, \
+            negative_infinity_default: -inf, double_inf_default: inf }, \
             test4: Some([Test { a: 10, b: 20 }, Test { a: 30, b: 40 }]), \
             testarrayofstring: Some([\"test1\", \"test2\"]), \
             testarrayoftables: None, enemy: None, testnestedflatbuffer: None, \
@@ -1794,7 +1807,10 @@ mod write_and_read_examples {
             vector_of_enums: None, signed_enum: None, \
             testrequirednestedflatbuffer: None, scalar_key_sorted_tables: None, \
             native_inline: None, long_enum_non_enum_default: (empty), \
-            long_enum_normal_default: LongOne }"
+            long_enum_normal_default: LongOne, nan_default: NaN, inf_default: \
+            inf, positive_inf_default: inf, infinity_default: inf, \
+            positive_infinity_default: inf, negative_inf_default: -inf, \
+            negative_infinity_default: -inf, double_inf_default: inf }"
         );
     }
 

tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/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 ? inf : _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) }
+  @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 ? -inf : _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 ? inf : _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: inf, 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(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: -inf, 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: inf, 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 = inf,
+    positiveInfDefault: Float32 = +inf,
+    infinityDefault: Float32 = infinity,
+    positiveInfinityDefault: Float32 = +infinity,
+    negativeInfDefault: Float32 = -inf,
+    negativeInfinityDefault: Float32 = -infinity,
+    doubleInfDefault: Double = inf
   ) -> 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 != nan {
+      try container.encodeIfPresent(nanDefault, forKey: .nanDefault)
+    }
+    if infDefault != inf {
+      try container.encodeIfPresent(infDefault, forKey: .infDefault)
+    }
+    if positiveInfDefault != +inf {
+      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 != -inf {
+      try container.encodeIfPresent(negativeInfDefault, forKey: .negativeInfDefault)
+    }
+    if negativeInfinityDefault != -infinity {
+      try container.encodeIfPresent(negativeInfinityDefault, forKey: .negativeInfinityDefault)
+    }
+    if doubleInfDefault != inf {
+      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 = inf
+    positiveInfDefault = +inf
+    infinityDefault = infinity
+    positiveInfinityDefault = +infinity
+    negativeInfDefault = -inf
+    negativeInfinityDefault = -infinity
+    doubleInfDefault = inf
   }
 
   public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Monster.self) }

tests/test.cpp

@@ -424,6 +424,12 @@ void UninitializedVectorTest() {
 void EqualOperatorTest() {
   MonsterT a;
   MonsterT b;
+  // We have to reset the fields that are NaN to zero to allow the equality
+  // to evaluate to true.
+  TEST_EQ(std::isnan(a.nan_default), true);
+  TEST_EQ(std::isnan(b.nan_default), true);
+  a.nan_default = 0;
+  b.nan_default = 0;
   TEST_EQ(b == a, true);
   TEST_EQ(b != a, false);
 
@@ -442,12 +448,14 @@ void EqualOperatorTest() {
   TEST_EQ(b != a, false);
 
   a.enemy.reset(new MonsterT());
+  a.enemy->nan_default = 0;
   TEST_EQ(b != a, true);
   a.enemy->mana = 33;
   TEST_EQ(b == a, false);
   TEST_EQ(b != a, true);
 
   b.enemy.reset(new MonsterT());
+  b.enemy->nan_default = 0;
   TEST_EQ(b == a, false);
   TEST_EQ(b != a, true);
   b.enemy->mana = 33;
@@ -461,6 +469,7 @@ void EqualOperatorTest() {
   TEST_EQ(b == a, false);
   TEST_EQ(b != a, true);
   a.enemy.reset(new MonsterT());
+  a.enemy->nan_default = 0;
   TEST_EQ(b == a, true);
   TEST_EQ(b != a, false);
 
@@ -474,23 +483,29 @@ void EqualOperatorTest() {
   {
     // Two tables are equal by default.
     MonsterT a, b;
+    a.nan_default = 0;
+    b.nan_default = 0;
     TEST_EQ(a == b, true);
 
     // Adding only a table to one of the monster vectors should make it not
     // equal (due to size mistmatch).
     a.testarrayoftables.push_back(
         flatbuffers::unique_ptr<MonsterT>(new MonsterT));
+    a.testarrayoftables.back()->nan_default = 0;
     TEST_EQ(a == b, false);
 
     // Adding an equalivant table to the other monster vector should make it
     // equal again.
     b.testarrayoftables.push_back(
         flatbuffers::unique_ptr<MonsterT>(new MonsterT));
+    b.testarrayoftables.back()->nan_default = 0;
     TEST_EQ(a == b, true);
 
     // Create two new monsters that are different.
     auto c = flatbuffers::unique_ptr<MonsterT>(new MonsterT);
     auto d = flatbuffers::unique_ptr<MonsterT>(new MonsterT);
+    c->nan_default = 0;
+    d->nan_default = 0;
     c->hp = 1;
     d->hp = 2;
     TEST_EQ(c == d, false);

tests/ts/my-game/example/monster.js

@@ -526,11 +526,95 @@ export class Monster {
         this.bb.writeUint64(this.bb_pos + offset, value);
         return true;
     }
+    nanDefault() {
+        const offset = this.bb.__offset(this.bb_pos, 112);
+        return offset ? this.bb.readFloat32(this.bb_pos + offset) : NaN;
+    }
+    mutate_nan_default(value) {
+        const offset = this.bb.__offset(this.bb_pos, 112);
+        if (offset === 0) {
+            return false;
+        }
+        this.bb.writeFloat32(this.bb_pos + offset, value);
+        return true;
+    }
+    infDefault() {
+        const offset = this.bb.__offset(this.bb_pos, 114);
+        return offset ? this.bb.readFloat32(this.bb_pos + offset) : Infinity;
+    }
+    mutate_inf_default(value) {
+        const offset = this.bb.__offset(this.bb_pos, 114);
+        if (offset === 0) {
+            return false;
+        }
+        this.bb.writeFloat32(this.bb_pos + offset, value);
+        return true;
+    }
+    positiveInfDefault() {
+        const offset = this.bb.__offset(this.bb_pos, 116);
+        return offset ? this.bb.readFloat32(this.bb_pos + offset) : Infinity;
+    }
+    mutate_positive_inf_default(value) {
+        const offset = this.bb.__offset(this.bb_pos, 116);
+        if (offset === 0) {
+            return false;
+        }
+        this.bb.writeFloat32(this.bb_pos + offset, value);
+        return true;
+    }
+    infinityDefault() {
+        const offset = this.bb.__offset(this.bb_pos, 118);
+        return offset ? this.bb.readFloat32(this.bb_pos + offset) : Infinity;
+    }
+    mutate_infinity_default(value) {
+        const offset = this.bb.__offset(this.bb_pos, 118);
+        if (offset === 0) {
+            return false;
+        }
+        this.bb.writeFloat32(this.bb_pos + offset, value);
+        return true;
+    }
+    positiveInfinityDefault() {
+        const offset = this.bb.__offset(this.bb_pos, 120);
+        return offset ? this.bb.readFloat32(this.bb_pos + offset) : Infinity;
+    }
+    mutate_positive_infinity_default(value) {
+        const offset = this.bb.__offset(this.bb_pos, 120);
+        if (offset === 0) {
+            return false;
+        }
+        this.bb.writeFloat32(this.bb_pos + offset, value);
+        return true;
+    }
+    negativeInfDefault() {
+        const offset = this.bb.__offset(this.bb_pos, 122);
+        return offset ? this.bb.readFloat32(this.bb_pos + offset) : -Infinity;
+    }
+    mutate_negative_inf_default(value) {
+        const offset = this.bb.__offset(this.bb_pos, 122);
+        if (offset === 0) {
+            return false;
+        }
+        this.bb.writeFloat32(this.bb_pos + offset, value);
+        return true;
+    }
+    negativeInfinityDefault() {
+        const offset = this.bb.__offset(this.bb_pos, 124);
+        return offset ? this.bb.readFloat32(this.bb_pos + offset) : -Infinity;
+    }
+    mutate_negative_infinity_default(value) {
+        const offset = this.bb.__offset(this.bb_pos, 124);
+        if (offset === 0) {
+            return false;
+        }
+        this.bb.writeFloat32(this.bb_pos + offset, value);
+        return true;
+    }
     static getFullyQualifiedName() {
         return 'MyGame_Example_Monster';
     }
     static startMonster(builder) {
-        builder.startObject(54);
+        builder.startObject(61);
     }
     static addPos(builder, posOffset) {
         builder.addFieldStruct(0, posOffset, 0);
@@ -870,6 +954,27 @@ export class Monster {
     static addLongEnumNormalDefault(builder, longEnumNormalDefault) {
         builder.addFieldInt64(53, longEnumNormalDefault, BigInt('2'));
     }
+    static addNanDefault(builder, nanDefault) {
+        builder.addFieldFloat32(54, nanDefault, NaN);
+    }
+    static addInfDefault(builder, infDefault) {
+        builder.addFieldFloat32(55, infDefault, Infinity);
+    }
+    static addPositiveInfDefault(builder, positiveInfDefault) {
+        builder.addFieldFloat32(56, positiveInfDefault, Infinity);
+    }
+    static addInfinityDefault(builder, infinityDefault) {
+        builder.addFieldFloat32(57, infinityDefault, Infinity);
+    }
+    static addPositiveInfinityDefault(builder, positiveInfinityDefault) {
+        builder.addFieldFloat32(58, positiveInfinityDefault, Infinity);
+    }
+    static addNegativeInfDefault(builder, negativeInfDefault) {
+        builder.addFieldFloat32(59, negativeInfDefault, -Infinity);
+    }
+    static addNegativeInfinityDefault(builder, negativeInfinityDefault) {
+        builder.addFieldFloat32(60, negativeInfinityDefault, -Infinity);
+    }
     static endMonster(builder) {
         const offset = builder.endObject();
         builder.requiredField(offset, 10); // name
@@ -906,7 +1011,7 @@ export class Monster {
                 return null;
             }
             return temp.unpack();
-        })(), this.bb.createScalarList(this.vectorOfEnums.bind(this), this.vectorOfEnumsLength()), this.signedEnum(), this.bb.createScalarList(this.testrequirednestedflatbuffer.bind(this), this.testrequirednestedflatbufferLength()), this.bb.createObjList(this.scalarKeySortedTables.bind(this), this.scalarKeySortedTablesLength()), (this.nativeInline() !== null ? this.nativeInline().unpack() : null), this.longEnumNonEnumDefault(), this.longEnumNormalDefault());
+        })(), this.bb.createScalarList(this.vectorOfEnums.bind(this), this.vectorOfEnumsLength()), this.signedEnum(), this.bb.createScalarList(this.testrequirednestedflatbuffer.bind(this), this.testrequirednestedflatbufferLength()), this.bb.createObjList(this.scalarKeySortedTables.bind(this), this.scalarKeySortedTablesLength()), (this.nativeInline() !== null ? this.nativeInline().unpack() : null), this.longEnumNonEnumDefault(), this.longEnumNormalDefault(), this.nanDefault(), this.infDefault(), this.positiveInfDefault(), this.infinityDefault(), this.positiveInfinityDefault(), this.negativeInfDefault(), this.negativeInfinityDefault());
     }
     unpackTo(_o) {
         _o.pos = (this.pos() !== null ? this.pos().unpack() : null);
@@ -980,10 +1085,17 @@ export class Monster {
         _o.nativeInline = (this.nativeInline() !== null ? this.nativeInline().unpack() : null);
         _o.longEnumNonEnumDefault = this.longEnumNonEnumDefault();
         _o.longEnumNormalDefault = this.longEnumNormalDefault();
+        _o.nanDefault = this.nanDefault();
+        _o.infDefault = this.infDefault();
+        _o.positiveInfDefault = this.positiveInfDefault();
+        _o.infinityDefault = this.infinityDefault();
+        _o.positiveInfinityDefault = this.positiveInfinityDefault();
+        _o.negativeInfDefault = this.negativeInfDefault();
+        _o.negativeInfinityDefault = this.negativeInfinityDefault();
     }
 }
 export class MonsterT {
-    constructor(pos = null, mana = 150, hp = 100, name = null, inventory = [], color = Color.Blue, testType = Any.NONE, test = null, test4 = [], testarrayofstring = [], testarrayoftables = [], enemy = null, testnestedflatbuffer = [], testempty = null, testbool = false, testhashs32Fnv1 = 0, testhashu32Fnv1 = 0, testhashs64Fnv1 = BigInt('0'), testhashu64Fnv1 = BigInt('0'), testhashs32Fnv1a = 0, testhashu32Fnv1a = 0, testhashs64Fnv1a = BigInt('0'), testhashu64Fnv1a = BigInt('0'), testarrayofbools = [], testf = 3.14159, testf2 = 3.0, testf3 = 0.0, testarrayofstring2 = [], testarrayofsortedstruct = [], flex = [], test5 = [], vectorOfLongs = [], vectorOfDoubles = [], parentNamespaceTest = null, vectorOfReferrables = [], singleWeakReference = BigInt('0'), vectorOfWeakReferences = [], vectorOfStrongReferrables = [], coOwningReference = BigInt('0'), vectorOfCoOwningReferences = [], nonOwningReference = BigInt('0'), vectorOfNonOwningReferences = [], anyUniqueType = AnyUniqueAliases.NONE, anyUnique = null, anyAmbiguousType = AnyAmbiguousAliases.NONE, anyAmbiguous = null, vectorOfEnums = [], signedEnum = Race.None, testrequirednestedflatbuffer = [], scalarKeySortedTables = [], nativeInline = null, longEnumNonEnumDefault = BigInt('0'), longEnumNormalDefault = BigInt('2')) {
+    constructor(pos = null, mana = 150, hp = 100, name = null, inventory = [], color = Color.Blue, testType = Any.NONE, test = null, test4 = [], testarrayofstring = [], testarrayoftables = [], enemy = null, testnestedflatbuffer = [], testempty = null, testbool = false, testhashs32Fnv1 = 0, testhashu32Fnv1 = 0, testhashs64Fnv1 = BigInt('0'), testhashu64Fnv1 = BigInt('0'), testhashs32Fnv1a = 0, testhashu32Fnv1a = 0, testhashs64Fnv1a = BigInt('0'), testhashu64Fnv1a = BigInt('0'), testarrayofbools = [], testf = 3.14159, testf2 = 3.0, testf3 = 0.0, testarrayofstring2 = [], testarrayofsortedstruct = [], flex = [], test5 = [], vectorOfLongs = [], vectorOfDoubles = [], parentNamespaceTest = null, vectorOfReferrables = [], singleWeakReference = BigInt('0'), vectorOfWeakReferences = [], vectorOfStrongReferrables = [], coOwningReference = BigInt('0'), vectorOfCoOwningReferences = [], nonOwningReference = BigInt('0'), vectorOfNonOwningReferences = [], anyUniqueType = AnyUniqueAliases.NONE, anyUnique = null, anyAmbiguousType = AnyAmbiguousAliases.NONE, anyAmbiguous = null, vectorOfEnums = [], signedEnum = Race.None, testrequirednestedflatbuffer = [], scalarKeySortedTables = [], nativeInline = null, longEnumNonEnumDefault = BigInt('0'), longEnumNormalDefault = BigInt('2'), nanDefault = NaN, infDefault = Infinity, positiveInfDefault = Infinity, infinityDefault = Infinity, positiveInfinityDefault = Infinity, negativeInfDefault = -Infinity, negativeInfinityDefault = -Infinity) {
         this.pos = pos;
         this.mana = mana;
         this.hp = hp;
@@ -1037,6 +1149,13 @@ export class MonsterT {
         this.nativeInline = nativeInline;
         this.longEnumNonEnumDefault = longEnumNonEnumDefault;
         this.longEnumNormalDefault = longEnumNormalDefault;
+        this.nanDefault = nanDefault;
+        this.infDefault = infDefault;
+        this.positiveInfDefault = positiveInfDefault;
+        this.infinityDefault = infinityDefault;
+        this.positiveInfinityDefault = positiveInfinityDefault;
+        this.negativeInfDefault = negativeInfDefault;
+        this.negativeInfinityDefault = negativeInfinityDefault;
     }
     pack(builder) {
         const name = (this.name !== null ? builder.createString(this.name) : 0);
@@ -1120,6 +1239,13 @@ export class MonsterT {
         Monster.addNativeInline(builder, (this.nativeInline !== null ? this.nativeInline.pack(builder) : 0));
         Monster.addLongEnumNonEnumDefault(builder, this.longEnumNonEnumDefault);
         Monster.addLongEnumNormalDefault(builder, this.longEnumNormalDefault);
+        Monster.addNanDefault(builder, this.nanDefault);
+        Monster.addInfDefault(builder, this.infDefault);
+        Monster.addPositiveInfDefault(builder, this.positiveInfDefault);
+        Monster.addInfinityDefault(builder, this.infinityDefault);
+        Monster.addPositiveInfinityDefault(builder, this.positiveInfinityDefault);
+        Monster.addNegativeInfDefault(builder, this.negativeInfDefault);
+        Monster.addNegativeInfinityDefault(builder, this.negativeInfinityDefault);
         return Monster.endMonster(builder);
     }
 }

tests/ts/my-game/example/monster.ts

@@ -683,12 +683,140 @@ mutate_long_enum_normal_default(value:bigint):boolean {
   return true;
 }
 
+nanDefault():number {
+  const offset = this.bb!.__offset(this.bb_pos, 112);
+  return offset ? this.bb!.readFloat32(this.bb_pos + offset) : NaN;
+}
+
+mutate_nan_default(value:number):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 112);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeFloat32(this.bb_pos + offset, value);
+  return true;
+}
+
+infDefault():number {
+  const offset = this.bb!.__offset(this.bb_pos, 114);
+  return offset ? this.bb!.readFloat32(this.bb_pos + offset) : Infinity;
+}
+
+mutate_inf_default(value:number):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 114);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeFloat32(this.bb_pos + offset, value);
+  return true;
+}
+
+positiveInfDefault():number {
+  const offset = this.bb!.__offset(this.bb_pos, 116);
+  return offset ? this.bb!.readFloat32(this.bb_pos + offset) : Infinity;
+}
+
+mutate_positive_inf_default(value:number):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 116);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeFloat32(this.bb_pos + offset, value);
+  return true;
+}
+
+infinityDefault():number {
+  const offset = this.bb!.__offset(this.bb_pos, 118);
+  return offset ? this.bb!.readFloat32(this.bb_pos + offset) : Infinity;
+}
+
+mutate_infinity_default(value:number):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 118);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeFloat32(this.bb_pos + offset, value);
+  return true;
+}
+
+positiveInfinityDefault():number {
+  const offset = this.bb!.__offset(this.bb_pos, 120);
+  return offset ? this.bb!.readFloat32(this.bb_pos + offset) : Infinity;
+}
+
+mutate_positive_infinity_default(value:number):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 120);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeFloat32(this.bb_pos + offset, value);
+  return true;
+}
+
+negativeInfDefault():number {
+  const offset = this.bb!.__offset(this.bb_pos, 122);
+  return offset ? this.bb!.readFloat32(this.bb_pos + offset) : -Infinity;
+}
+
+mutate_negative_inf_default(value:number):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 122);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeFloat32(this.bb_pos + offset, value);
+  return true;
+}
+
+negativeInfinityDefault():number {
+  const offset = this.bb!.__offset(this.bb_pos, 124);
+  return offset ? this.bb!.readFloat32(this.bb_pos + offset) : -Infinity;
+}
+
+mutate_negative_infinity_default(value:number):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 124);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeFloat32(this.bb_pos + offset, value);
+  return true;
+}
+
+doubleInfDefault():number {
+  const offset = this.bb!.__offset(this.bb_pos, 126);
+  return offset ? this.bb!.readFloat64(this.bb_pos + offset) : Infinity;
+}
+
+mutate_double_inf_default(value:number):boolean {
+  const offset = this.bb!.__offset(this.bb_pos, 126);
+
+  if (offset === 0) {
+    return false;
+  }
+
+  this.bb!.writeFloat64(this.bb_pos + offset, value);
+  return true;
+}
+
 static getFullyQualifiedName():string {
   return 'MyGame_Example_Monster';
 }
 
 static startMonster(builder:flatbuffers.Builder) {
-  builder.startObject(54);
+  builder.startObject(62);
 }
 
 static addPos(builder:flatbuffers.Builder, posOffset:flatbuffers.Offset) {
@@ -1124,6 +1252,38 @@ static addLongEnumNormalDefault(builder:flatbuffers.Builder, longEnumNormalDefau
   builder.addFieldInt64(53, longEnumNormalDefault, BigInt('2'));
 }
 
+static addNanDefault(builder:flatbuffers.Builder, nanDefault:number) {
+  builder.addFieldFloat32(54, nanDefault, NaN);
+}
+
+static addInfDefault(builder:flatbuffers.Builder, infDefault:number) {
+  builder.addFieldFloat32(55, infDefault, Infinity);
+}
+
+static addPositiveInfDefault(builder:flatbuffers.Builder, positiveInfDefault:number) {
+  builder.addFieldFloat32(56, positiveInfDefault, Infinity);
+}
+
+static addInfinityDefault(builder:flatbuffers.Builder, infinityDefault:number) {
+  builder.addFieldFloat32(57, infinityDefault, Infinity);
+}
+
+static addPositiveInfinityDefault(builder:flatbuffers.Builder, positiveInfinityDefault:number) {
+  builder.addFieldFloat32(58, positiveInfinityDefault, Infinity);
+}
+
+static addNegativeInfDefault(builder:flatbuffers.Builder, negativeInfDefault:number) {
+  builder.addFieldFloat32(59, negativeInfDefault, -Infinity);
+}
+
+static addNegativeInfinityDefault(builder:flatbuffers.Builder, negativeInfinityDefault:number) {
+  builder.addFieldFloat32(60, negativeInfinityDefault, -Infinity);
+}
+
+static addDoubleInfDefault(builder:flatbuffers.Builder, doubleInfDefault:number) {
+  builder.addFieldFloat64(61, doubleInfDefault, Infinity);
+}
+
 static endMonster(builder:flatbuffers.Builder):flatbuffers.Offset {
   const offset = builder.endObject();
   builder.requiredField(offset, 10) // name
@@ -1213,7 +1373,15 @@ unpack(): MonsterT {
     this.bb!.createObjList<Stat, StatT>(this.scalarKeySortedTables.bind(this), this.scalarKeySortedTablesLength()),
     (this.nativeInline() !== null ? this.nativeInline()!.unpack() : null),
     this.longEnumNonEnumDefault(),
-    this.longEnumNormalDefault()
+    this.longEnumNormalDefault(),
+    this.nanDefault(),
+    this.infDefault(),
+    this.positiveInfDefault(),
+    this.infinityDefault(),
+    this.positiveInfinityDefault(),
+    this.negativeInfDefault(),
+    this.negativeInfinityDefault(),
+    this.doubleInfDefault()
   );
 }
 
@@ -1284,6 +1452,14 @@ unpackTo(_o: MonsterT): void {
   _o.nativeInline = (this.nativeInline() !== null ? this.nativeInline()!.unpack() : null);
   _o.longEnumNonEnumDefault = this.longEnumNonEnumDefault();
   _o.longEnumNormalDefault = this.longEnumNormalDefault();
+  _o.nanDefault = this.nanDefault();
+  _o.infDefault = this.infDefault();
+  _o.positiveInfDefault = this.positiveInfDefault();
+  _o.infinityDefault = this.infinityDefault();
+  _o.positiveInfinityDefault = this.positiveInfinityDefault();
+  _o.negativeInfDefault = this.negativeInfDefault();
+  _o.negativeInfinityDefault = this.negativeInfinityDefault();
+  _o.doubleInfDefault = this.doubleInfDefault();
 }
 }
 
@@ -1341,7 +1517,15 @@ constructor(
   public scalarKeySortedTables: (StatT)[] = [],
   public nativeInline: TestT|null = null,
   public longEnumNonEnumDefault: bigint = BigInt('0'),
-  public longEnumNormalDefault: bigint = BigInt('2')
+  public longEnumNormalDefault: bigint = BigInt('2'),
+  public nanDefault: number = NaN,
+  public infDefault: number = Infinity,
+  public positiveInfDefault: number = Infinity,
+  public infinityDefault: number = Infinity,
+  public positiveInfinityDefault: number = Infinity,
+  public negativeInfDefault: number = -Infinity,
+  public negativeInfinityDefault: number = -Infinity,
+  public doubleInfDefault: number = Infinity
 ){}
 
 
@@ -1428,6 +1612,14 @@ pack(builder:flatbuffers.Builder): flatbuffers.Offset {
   Monster.addNativeInline(builder, (this.nativeInline !== null ? this.nativeInline!.pack(builder) : 0));
   Monster.addLongEnumNonEnumDefault(builder, this.longEnumNonEnumDefault);
   Monster.addLongEnumNormalDefault(builder, this.longEnumNormalDefault);
+  Monster.addNanDefault(builder, this.nanDefault);
+  Monster.addInfDefault(builder, this.infDefault);
+  Monster.addPositiveInfDefault(builder, this.positiveInfDefault);
+  Monster.addInfinityDefault(builder, this.infinityDefault);
+  Monster.addPositiveInfinityDefault(builder, this.positiveInfinityDefault);
+  Monster.addNegativeInfDefault(builder, this.negativeInfDefault);
+  Monster.addNegativeInfinityDefault(builder, this.negativeInfinityDefault);
+  Monster.addDoubleInfDefault(builder, this.doubleInfDefault);
 
   return Monster.endMonster(builder);
 }

tests/ts/ts-flat-files/monster_test_generated.ts

@@ -1152,8 +1152,48 @@ longEnumNormalDefault():bigint {
   return offset ? this.bb!.readUint64(this.bb_pos + offset) : BigInt('2');
 }
 
+nanDefault():number {
+  const offset = this.bb!.__offset(this.bb_pos, 112);
+  return offset ? this.bb!.readFloat32(this.bb_pos + offset) : NaN;
+}
+
+infDefault():number {
+  const offset = this.bb!.__offset(this.bb_pos, 114);
+  return offset ? this.bb!.readFloat32(this.bb_pos + offset) : Infinity;
+}
+
+positiveInfDefault():number {
+  const offset = this.bb!.__offset(this.bb_pos, 116);
+  return offset ? this.bb!.readFloat32(this.bb_pos + offset) : Infinity;
+}
+
+infinityDefault():number {
+  const offset = this.bb!.__offset(this.bb_pos, 118);
+  return offset ? this.bb!.readFloat32(this.bb_pos + offset) : Infinity;
+}
+
+positiveInfinityDefault():number {
+  const offset = this.bb!.__offset(this.bb_pos, 120);
+  return offset ? this.bb!.readFloat32(this.bb_pos + offset) : Infinity;
+}
+
+negativeInfDefault():number {
+  const offset = this.bb!.__offset(this.bb_pos, 122);
+  return offset ? this.bb!.readFloat32(this.bb_pos + offset) : -Infinity;
+}
+
+negativeInfinityDefault():number {
+  const offset = this.bb!.__offset(this.bb_pos, 124);
+  return offset ? this.bb!.readFloat32(this.bb_pos + offset) : -Infinity;
+}
+
+doubleInfDefault():number {
+  const offset = this.bb!.__offset(this.bb_pos, 126);
+  return offset ? this.bb!.readFloat64(this.bb_pos + offset) : Infinity;
+}
+
 static startMonster(builder:flatbuffers.Builder) {
-  builder.startObject(54);
+  builder.startObject(62);
 }
 
 static addPos(builder:flatbuffers.Builder, posOffset:flatbuffers.Offset) {
@@ -1589,6 +1629,38 @@ static addLongEnumNormalDefault(builder:flatbuffers.Builder, longEnumNormalDefau
   builder.addFieldInt64(53, longEnumNormalDefault, BigInt('2'));
 }
 
+static addNanDefault(builder:flatbuffers.Builder, nanDefault:number) {
+  builder.addFieldFloat32(54, nanDefault, NaN);
+}
+
+static addInfDefault(builder:flatbuffers.Builder, infDefault:number) {
+  builder.addFieldFloat32(55, infDefault, Infinity);
+}
+
+static addPositiveInfDefault(builder:flatbuffers.Builder, positiveInfDefault:number) {
+  builder.addFieldFloat32(56, positiveInfDefault, Infinity);
+}
+
+static addInfinityDefault(builder:flatbuffers.Builder, infinityDefault:number) {
+  builder.addFieldFloat32(57, infinityDefault, Infinity);
+}
+
+static addPositiveInfinityDefault(builder:flatbuffers.Builder, positiveInfinityDefault:number) {
+  builder.addFieldFloat32(58, positiveInfinityDefault, Infinity);
+}
+
+static addNegativeInfDefault(builder:flatbuffers.Builder, negativeInfDefault:number) {
+  builder.addFieldFloat32(59, negativeInfDefault, -Infinity);
+}
+
+static addNegativeInfinityDefault(builder:flatbuffers.Builder, negativeInfinityDefault:number) {
+  builder.addFieldFloat32(60, negativeInfinityDefault, -Infinity);
+}
+
+static addDoubleInfDefault(builder:flatbuffers.Builder, doubleInfDefault:number) {
+  builder.addFieldFloat64(61, doubleInfDefault, Infinity);
+}
+
 static endMonster(builder:flatbuffers.Builder):flatbuffers.Offset {
   const offset = builder.endObject();
   builder.requiredField(offset, 10) // name