[C++] Fix compile failure on Object API union construction for struct member (#6923)

* Add dedicated traits to Object API version of unions.

* Add suppression for unused parameters on unions of structs.

tests/union_vector/union_vector_generated.h

@@ -14,6 +14,12 @@ struct Rapunzel;
 
 struct BookReader;
 
+struct FallingTub;
+
+struct HandFan;
+struct HandFanBuilder;
+struct HandFanT;
+
 struct Movie;
 struct MovieBuilder;
 struct MovieT;
@@ -24,6 +30,10 @@ bool operator==(const Rapunzel &lhs, const Rapunzel &rhs);
 bool operator!=(const Rapunzel &lhs, const Rapunzel &rhs);
 bool operator==(const BookReader &lhs, const BookReader &rhs);
 bool operator!=(const BookReader &lhs, const BookReader &rhs);
+bool operator==(const FallingTub &lhs, const FallingTub &rhs);
+bool operator!=(const FallingTub &lhs, const FallingTub &rhs);
+bool operator==(const HandFanT &lhs, const HandFanT &rhs);
+bool operator!=(const HandFanT &lhs, const HandFanT &rhs);
 bool operator==(const MovieT &lhs, const MovieT &rhs);
 bool operator!=(const MovieT &lhs, const MovieT &rhs);
 
@@ -33,6 +43,10 @@ inline const flatbuffers::TypeTable *RapunzelTypeTable();
 
 inline const flatbuffers::TypeTable *BookReaderTypeTable();
 
+inline const flatbuffers::TypeTable *FallingTubTypeTable();
+
+inline const flatbuffers::TypeTable *HandFanTypeTable();
+
 inline const flatbuffers::TypeTable *MovieTypeTable();
 
 enum Character : uint8_t {
@@ -194,6 +208,139 @@ inline bool operator!=(const CharacterUnion &lhs, const CharacterUnion &rhs) {
 bool VerifyCharacter(flatbuffers::Verifier &verifier, const void *obj, Character type);
 bool VerifyCharacterVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
 
+enum Gadget : uint8_t {
+  Gadget_NONE = 0,
+  Gadget_FallingTub = 1,
+  Gadget_HandFan = 2,
+  Gadget_MIN = Gadget_NONE,
+  Gadget_MAX = Gadget_HandFan
+};
+
+inline const Gadget (&EnumValuesGadget())[3] {
+  static const Gadget values[] = {
+    Gadget_NONE,
+    Gadget_FallingTub,
+    Gadget_HandFan
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesGadget() {
+  static const char * const names[4] = {
+    "NONE",
+    "FallingTub",
+    "HandFan",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameGadget(Gadget e) {
+  if (flatbuffers::IsOutRange(e, Gadget_NONE, Gadget_HandFan)) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesGadget()[index];
+}
+
+template<typename T> struct GadgetTraits {
+  static const Gadget enum_value = Gadget_NONE;
+};
+
+template<> struct GadgetTraits<FallingTub> {
+  static const Gadget enum_value = Gadget_FallingTub;
+};
+
+template<> struct GadgetTraits<HandFan> {
+  static const Gadget enum_value = Gadget_HandFan;
+};
+
+template<typename T> struct GadgetUnionTraits {
+  static const Gadget enum_value = Gadget_NONE;
+};
+
+template<> struct GadgetUnionTraits<FallingTub> {
+  static const Gadget enum_value = Gadget_FallingTub;
+};
+
+template<> struct GadgetUnionTraits<HandFanT> {
+  static const Gadget enum_value = Gadget_HandFan;
+};
+
+struct GadgetUnion {
+  Gadget type;
+  void *value;
+
+  GadgetUnion() : type(Gadget_NONE), value(nullptr) {}
+  GadgetUnion(GadgetUnion&& u) FLATBUFFERS_NOEXCEPT :
+    type(Gadget_NONE), value(nullptr)
+    { std::swap(type, u.type); std::swap(value, u.value); }
+  GadgetUnion(const GadgetUnion &);
+  GadgetUnion &operator=(const GadgetUnion &u)
+    { GadgetUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; }
+  GadgetUnion &operator=(GadgetUnion &&u) FLATBUFFERS_NOEXCEPT
+    { std::swap(type, u.type); std::swap(value, u.value); return *this; }
+  ~GadgetUnion() { Reset(); }
+
+  void Reset();
+
+  template <typename T>
+  void Set(T&& val) {
+    typedef typename std::remove_reference<T>::type RT;
+    Reset();
+    type = GadgetUnionTraits<RT>::enum_value;
+    if (type != Gadget_NONE) {
+      value = new RT(std::forward<T>(val));
+    }
+  }
+
+  static void *UnPack(const void *obj, Gadget type, const flatbuffers::resolver_function_t *resolver);
+  flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
+
+  FallingTub *AsFallingTub() {
+    return type == Gadget_FallingTub ?
+      reinterpret_cast<FallingTub *>(value) : nullptr;
+  }
+  const FallingTub *AsFallingTub() const {
+    return type == Gadget_FallingTub ?
+      reinterpret_cast<const FallingTub *>(value) : nullptr;
+  }
+  HandFanT *AsHandFan() {
+    return type == Gadget_HandFan ?
+      reinterpret_cast<HandFanT *>(value) : nullptr;
+  }
+  const HandFanT *AsHandFan() const {
+    return type == Gadget_HandFan ?
+      reinterpret_cast<const HandFanT *>(value) : nullptr;
+  }
+};
+
+
+inline bool operator==(const GadgetUnion &lhs, const GadgetUnion &rhs) {
+  if (lhs.type != rhs.type) return false;
+  switch (lhs.type) {
+    case Gadget_NONE: {
+      return true;
+    }
+    case Gadget_FallingTub: {
+      return *(reinterpret_cast<const FallingTub *>(lhs.value)) ==
+             *(reinterpret_cast<const FallingTub *>(rhs.value));
+    }
+    case Gadget_HandFan: {
+      return *(reinterpret_cast<const HandFanT *>(lhs.value)) ==
+             *(reinterpret_cast<const HandFanT *>(rhs.value));
+    }
+    default: {
+      return false;
+    }
+  }
+}
+
+inline bool operator!=(const GadgetUnion &lhs, const GadgetUnion &rhs) {
+    return !(lhs == rhs);
+}
+
+bool VerifyGadget(flatbuffers::Verifier &verifier, const void *obj, Gadget type);
+bool VerifyGadgetVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
+
 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Rapunzel FLATBUFFERS_FINAL_CLASS {
  private:
   int32_t hair_length_;
@@ -266,6 +413,42 @@ inline bool operator!=(const BookReader &lhs, const BookReader &rhs) {
 }
 
 
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) FallingTub FLATBUFFERS_FINAL_CLASS {
+ private:
+  int32_t weight_;
+
+ public:
+  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
+    return FallingTubTypeTable();
+  }
+  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
+    return "FallingTub";
+  }
+  FallingTub()
+      : weight_(0) {
+  }
+  FallingTub(int32_t _weight)
+      : weight_(flatbuffers::EndianScalar(_weight)) {
+  }
+  int32_t weight() const {
+    return flatbuffers::EndianScalar(weight_);
+  }
+  void mutate_weight(int32_t _weight) {
+    flatbuffers::WriteScalar(&weight_, _weight);
+  }
+};
+FLATBUFFERS_STRUCT_END(FallingTub, 4);
+
+inline bool operator==(const FallingTub &lhs, const FallingTub &rhs) {
+  return
+      (lhs.weight() == rhs.weight());
+}
+
+inline bool operator!=(const FallingTub &lhs, const FallingTub &rhs) {
+    return !(lhs == rhs);
+}
+
+
 struct AttackerT : public flatbuffers::NativeTable {
   typedef Attacker TableType;
   static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
@@ -330,6 +513,70 @@ inline flatbuffers::Offset<Attacker> CreateAttacker(
 
 flatbuffers::Offset<Attacker> CreateAttacker(flatbuffers::FlatBufferBuilder &_fbb, const AttackerT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
 
+struct HandFanT : public flatbuffers::NativeTable {
+  typedef HandFan TableType;
+  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
+    return "HandFanT";
+  }
+  int32_t length = 0;
+};
+
+struct HandFan FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef HandFanT NativeTableType;
+  typedef HandFanBuilder Builder;
+  static const flatbuffers::TypeTable *MiniReflectTypeTable() {
+    return HandFanTypeTable();
+  }
+  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
+    return "HandFan";
+  }
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_LENGTH = 4
+  };
+  int32_t length() const {
+    return GetField<int32_t>(VT_LENGTH, 0);
+  }
+  bool mutate_length(int32_t _length = 0) {
+    return SetField<int32_t>(VT_LENGTH, _length, 0);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int32_t>(verifier, VT_LENGTH) &&
+           verifier.EndTable();
+  }
+  HandFanT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  void UnPackTo(HandFanT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+  static flatbuffers::Offset<HandFan> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HandFanT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+struct HandFanBuilder {
+  typedef HandFan Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_length(int32_t length) {
+    fbb_.AddElement<int32_t>(HandFan::VT_LENGTH, length, 0);
+  }
+  explicit HandFanBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  flatbuffers::Offset<HandFan> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<HandFan>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<HandFan> CreateHandFan(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int32_t length = 0) {
+  HandFanBuilder builder_(_fbb);
+  builder_.add_length(length);
+  return builder_.Finish();
+}
+
+flatbuffers::Offset<HandFan> CreateHandFan(flatbuffers::FlatBufferBuilder &_fbb, const HandFanT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
 struct MovieT : public flatbuffers::NativeTable {
   typedef Movie TableType;
   static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
@@ -507,6 +754,43 @@ inline flatbuffers::Offset<Attacker> CreateAttacker(flatbuffers::FlatBufferBuild
 }
 
 
+inline bool operator==(const HandFanT &lhs, const HandFanT &rhs) {
+  return
+      (lhs.length == rhs.length);
+}
+
+inline bool operator!=(const HandFanT &lhs, const HandFanT &rhs) {
+    return !(lhs == rhs);
+}
+
+
+inline HandFanT *HandFan::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+  auto _o = std::unique_ptr<HandFanT>(new HandFanT());
+  UnPackTo(_o.get(), _resolver);
+  return _o.release();
+}
+
+inline void HandFan::UnPackTo(HandFanT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+  (void)_o;
+  (void)_resolver;
+  { auto _e = length(); _o->length = _e; }
+}
+
+inline flatbuffers::Offset<HandFan> HandFan::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HandFanT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+  return CreateHandFan(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<HandFan> CreateHandFan(flatbuffers::FlatBufferBuilder &_fbb, const HandFanT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+  (void)_rehasher;
+  (void)_o;
+  struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HandFanT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+  auto _length = _o->length;
+  return CreateHandFan(
+      _fbb,
+      _length);
+}
+
+
 inline bool operator==(const MovieT &lhs, const MovieT &rhs) {
   return
       (lhs.main_character == rhs.main_character) &&
@@ -596,6 +880,7 @@ inline bool VerifyCharacterVector(flatbuffers::Verifier &verifier, const flatbuf
 }
 
 inline void *CharacterUnion::UnPack(const void *obj, Character type, const flatbuffers::resolver_function_t *resolver) {
+  (void)resolver;
   switch (type) {
     case Character_MuLan: {
       auto ptr = reinterpret_cast<const Attacker *>(obj);
@@ -626,6 +911,7 @@ inline void *CharacterUnion::UnPack(const void *obj, Character type, const flatb
 }
 
 inline flatbuffers::Offset<void> CharacterUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
+  (void)_rehasher;
   switch (type) {
     case Character_MuLan: {
       auto ptr = reinterpret_cast<const AttackerT *>(value);
@@ -724,6 +1010,97 @@ inline void CharacterUnion::Reset() {
   type = Character_NONE;
 }
 
+inline bool VerifyGadget(flatbuffers::Verifier &verifier, const void *obj, Gadget type) {
+  switch (type) {
+    case Gadget_NONE: {
+      return true;
+    }
+    case Gadget_FallingTub: {
+      return verifier.Verify<FallingTub>(static_cast<const uint8_t *>(obj), 0);
+    }
+    case Gadget_HandFan: {
+      auto ptr = reinterpret_cast<const HandFan *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    default: return true;
+  }
+}
+
+inline bool VerifyGadgetVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
+  if (!values || !types) return !values && !types;
+  if (values->size() != types->size()) return false;
+  for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
+    if (!VerifyGadget(
+        verifier,  values->Get(i), types->GetEnum<Gadget>(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+inline void *GadgetUnion::UnPack(const void *obj, Gadget type, const flatbuffers::resolver_function_t *resolver) {
+  (void)resolver;
+  switch (type) {
+    case Gadget_FallingTub: {
+      auto ptr = reinterpret_cast<const FallingTub *>(obj);
+      return new FallingTub(*ptr);
+    }
+    case Gadget_HandFan: {
+      auto ptr = reinterpret_cast<const HandFan *>(obj);
+      return ptr->UnPack(resolver);
+    }
+    default: return nullptr;
+  }
+}
+
+inline flatbuffers::Offset<void> GadgetUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
+  (void)_rehasher;
+  switch (type) {
+    case Gadget_FallingTub: {
+      auto ptr = reinterpret_cast<const FallingTub *>(value);
+      return _fbb.CreateStruct(*ptr).Union();
+    }
+    case Gadget_HandFan: {
+      auto ptr = reinterpret_cast<const HandFanT *>(value);
+      return CreateHandFan(_fbb, ptr, _rehasher).Union();
+    }
+    default: return 0;
+  }
+}
+
+inline GadgetUnion::GadgetUnion(const GadgetUnion &u) : type(u.type), value(nullptr) {
+  switch (type) {
+    case Gadget_FallingTub: {
+      value = new FallingTub(*reinterpret_cast<FallingTub *>(u.value));
+      break;
+    }
+    case Gadget_HandFan: {
+      value = new HandFanT(*reinterpret_cast<HandFanT *>(u.value));
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+inline void GadgetUnion::Reset() {
+  switch (type) {
+    case Gadget_FallingTub: {
+      auto ptr = reinterpret_cast<FallingTub *>(value);
+      delete ptr;
+      break;
+    }
+    case Gadget_HandFan: {
+      auto ptr = reinterpret_cast<HandFanT *>(value);
+      delete ptr;
+      break;
+    }
+    default: break;
+  }
+  value = nullptr;
+  type = Gadget_NONE;
+}
+
 inline const flatbuffers::TypeTable *CharacterTypeTable() {
   static const flatbuffers::TypeCode type_codes[] = {
     { flatbuffers::ET_SEQUENCE, 0, -1 },
@@ -754,6 +1131,27 @@ inline const flatbuffers::TypeTable *CharacterTypeTable() {
   return &tt;
 }
 
+inline const flatbuffers::TypeTable *GadgetTypeTable() {
+  static const flatbuffers::TypeCode type_codes[] = {
+    { flatbuffers::ET_SEQUENCE, 0, -1 },
+    { flatbuffers::ET_SEQUENCE, 0, 0 },
+    { flatbuffers::ET_SEQUENCE, 0, 1 }
+  };
+  static const flatbuffers::TypeFunction type_refs[] = {
+    FallingTubTypeTable,
+    HandFanTypeTable
+  };
+  static const char * const names[] = {
+    "NONE",
+    "FallingTub",
+    "HandFan"
+  };
+  static const flatbuffers::TypeTable tt = {
+    flatbuffers::ST_UNION, 3, type_codes, type_refs, nullptr, nullptr, names
+  };
+  return &tt;
+}
+
 inline const flatbuffers::TypeTable *AttackerTypeTable() {
   static const flatbuffers::TypeCode type_codes[] = {
     { flatbuffers::ET_INT, 0, -1 }
@@ -795,6 +1193,33 @@ inline const flatbuffers::TypeTable *BookReaderTypeTable() {
   return &tt;
 }
 
+inline const flatbuffers::TypeTable *FallingTubTypeTable() {
+  static const flatbuffers::TypeCode type_codes[] = {
+    { flatbuffers::ET_INT, 0, -1 }
+  };
+  static const int64_t values[] = { 0, 4 };
+  static const char * const names[] = {
+    "weight"
+  };
+  static const flatbuffers::TypeTable tt = {
+    flatbuffers::ST_STRUCT, 1, type_codes, nullptr, nullptr, values, names
+  };
+  return &tt;
+}
+
+inline const flatbuffers::TypeTable *HandFanTypeTable() {
+  static const flatbuffers::TypeCode type_codes[] = {
+    { flatbuffers::ET_INT, 0, -1 }
+  };
+  static const char * const names[] = {
+    "length"
+  };
+  static const flatbuffers::TypeTable tt = {
+    flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names
+  };
+  return &tt;
+}
+
 inline const flatbuffers::TypeTable *MovieTypeTable() {
   static const flatbuffers::TypeCode type_codes[] = {
     { flatbuffers::ET_UTYPE, 0, 0 },