BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-06-02 12:05:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
+/-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>
This commit is contained in:
James Kuszmaul
2022-11-08 10:59:46 -08:00
committed by GitHub
parent 001adf782d
commit 8aa8b9139e
41 changed files with 8217 additions and 4647 deletions
Download Patch File Download Diff File Expand all files Collapse all files

222
tests/cpp17/generated_cpp17/monster_test_generated.h
View File

@@ -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;
}