Fix 64-bit numeric enum values in typescript (#7135)

* Fix 64-bit default numeric enum values in typescript

If you had a default value that wasn't a valid enum value (e.g., a zero
if you used a bit_flag setting, like you get with AdvancedFeatures
in reflection.fbs), we weren't using BigInt.

* Run generate_code.py

* [DART] Handle deprecated fields & invalid enum defaults

* Update .NET test

tests/monster_test_serialize/mod.rs

@@ -7,6 +7,8 @@ pub mod my_game {
     pub use self::color_generated::*;
     mod race_generated;
     pub use self::race_generated::*;
+    mod long_enum_generated;
+    pub use self::long_enum_generated::*;
     mod any_generated;
     pub use self::any_generated::*;
     mod any_unique_aliases_generated;

tests/monster_test_serialize/my_game/example/long_enum_generated.rs

@@ -0,0 +1,74 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+extern crate flatbuffers;
+use std::mem;
+use std::cmp::Ordering;
+extern crate serde;
+use self::serde::ser::{Serialize, Serializer, SerializeStruct};
+use self::flatbuffers::{EndianScalar, Follow};
+use super::*;
+#[allow(non_upper_case_globals)]
+mod bitflags_long_enum {
+  flatbuffers::bitflags::bitflags! {
+    #[derive(Default)]
+    pub struct LongEnum: u64 {
+      const LongOne = 2;
+      const LongTwo = 4;
+      const LongBig = 1099511627776;
+    }
+  }
+}
+pub use self::bitflags_long_enum::LongEnum;
+
+impl Serialize for LongEnum {
+  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+  where
+    S: Serializer,
+  {
+    serializer.serialize_u32(self.bits() as u32)
+  }
+}
+
+impl<'a> flatbuffers::Follow<'a> for LongEnum {
+  type Inner = Self;
+  #[inline]
+  fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    let b = unsafe {
+      flatbuffers::read_scalar_at::<u64>(buf, loc)
+    };
+    unsafe { Self::from_bits_unchecked(b) }
+  }
+}
+
+impl flatbuffers::Push for LongEnum {
+    type Output = LongEnum;
+    #[inline]
+    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
+        unsafe { flatbuffers::emplace_scalar::<u64>(dst, self.bits()); }
+    }
+}
+
+impl flatbuffers::EndianScalar for LongEnum {
+  #[inline]
+  fn to_little_endian(self) -> Self {
+    let b = u64::to_le(self.bits());
+    unsafe { Self::from_bits_unchecked(b) }
+  }
+  #[inline]
+  #[allow(clippy::wrong_self_convention)]
+  fn from_little_endian(self) -> Self {
+    let b = u64::from_le(self.bits());
+    unsafe { Self::from_bits_unchecked(b) }
+  }
+}
+
+impl<'a> flatbuffers::Verifiable for LongEnum {
+  #[inline]
+  fn run_verifier(
+    v: &mut flatbuffers::Verifier, pos: usize
+  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
+    use self::flatbuffers::Verifiable;
+    u64::run_verifier(v, pos)
+  }
+}
+
+impl flatbuffers::SimpleToVerifyInSlice for LongEnum {}

tests/monster_test_serialize/my_game/example/monster_generated.rs

@@ -74,6 +74,8 @@ impl<'a> Monster<'a> {
   pub const VT_TESTREQUIREDNESTEDFLATBUFFER: flatbuffers::VOffsetT = 102;
   pub const VT_SCALAR_KEY_SORTED_TABLES: flatbuffers::VOffsetT = 104;
   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 fn get_fully_qualified_name() -> &'static str {
     "MyGame.Example.Monster"
@@ -89,6 +91,8 @@ impl<'a> Monster<'a> {
     args: &'args MonsterArgs<'args>
   ) -> flatbuffers::WIPOffset<Monster<'bldr>> {
     let mut builder = MonsterBuilder::new(_fbb);
+    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);
     builder.add_co_owning_reference(args.co_owning_reference);
     builder.add_single_weak_reference(args.single_weak_reference);
@@ -299,6 +303,8 @@ impl<'a> Monster<'a> {
     let native_inline = self.native_inline().map(|x| {
       x.unpack()
     });
+    let long_enum_non_enum_default = self.long_enum_non_enum_default();
+    let long_enum_normal_default = self.long_enum_normal_default();
     MonsterT {
       pos,
       mana,
@@ -348,6 +354,8 @@ impl<'a> Monster<'a> {
       testrequirednestedflatbuffer,
       scalar_key_sorted_tables,
       native_inline,
+      long_enum_non_enum_default,
+      long_enum_normal_default,
     }
   }
 
@@ -580,6 +588,14 @@ impl<'a> Monster<'a> {
     self._tab.get::<Test>(Monster::VT_NATIVE_INLINE, None)
   }
   #[inline]
+  pub fn long_enum_non_enum_default(&self) -> LongEnum {
+    self._tab.get::<LongEnum>(Monster::VT_LONG_ENUM_NON_ENUM_DEFAULT, Some(Default::default())).unwrap()
+  }
+  #[inline]
+  pub fn long_enum_normal_default(&self) -> LongEnum {
+    self._tab.get::<LongEnum>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, Some(LongEnum::LongOne)).unwrap()
+  }
+  #[inline]
   #[allow(non_snake_case)]
   pub fn test_as_monster(&self) -> Option<Monster<'a>> {
     if self.test_type() == Any::Monster {
@@ -747,6 +763,8 @@ impl flatbuffers::Verifiable for Monster<'_> {
      .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, u8>>>("testrequirednestedflatbuffer", Self::VT_TESTREQUIREDNESTEDFLATBUFFER, false)?
      .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Stat>>>>("scalar_key_sorted_tables", Self::VT_SCALAR_KEY_SORTED_TABLES, false)?
      .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)?
      .finish();
     Ok(())
   }
@@ -803,6 +821,8 @@ pub struct MonsterArgs<'a> {
     pub testrequirednestedflatbuffer: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, u8>>>,
     pub scalar_key_sorted_tables: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Stat<'a>>>>>,
     pub native_inline: Option<&'a Test>,
+    pub long_enum_non_enum_default: LongEnum,
+    pub long_enum_normal_default: LongEnum,
 }
 impl<'a> Default for MonsterArgs<'a> {
   #[inline]
@@ -859,6 +879,8 @@ impl<'a> Default for MonsterArgs<'a> {
       testrequirednestedflatbuffer: None,
       scalar_key_sorted_tables: None,
       native_inline: None,
+      long_enum_non_enum_default: Default::default(),
+      long_enum_normal_default: LongEnum::LongOne,
     }
   }
 }
@@ -868,7 +890,7 @@ impl Serialize for Monster<'_> {
   where
     S: Serializer,
   {
-    let mut s = serializer.serialize_struct("Monster", 52)?;
+    let mut s = serializer.serialize_struct("Monster", 54)?;
       if let Some(f) = self.pos() {
         s.serialize_field("pos", &f)?;
       } else {
@@ -1074,6 +1096,8 @@ impl Serialize for Monster<'_> {
       } else {
         s.skip_field("native_inline")?;
       }
+      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.end()
   }
 }
@@ -1288,6 +1312,14 @@ impl<'a: 'b, 'b> MonsterBuilder<'a, 'b> {
     self.fbb_.push_slot_always::<&Test>(Monster::VT_NATIVE_INLINE, native_inline);
   }
   #[inline]
+  pub fn add_long_enum_non_enum_default(&mut self, long_enum_non_enum_default: LongEnum) {
+    self.fbb_.push_slot::<LongEnum>(Monster::VT_LONG_ENUM_NON_ENUM_DEFAULT, long_enum_non_enum_default, Default::default());
+  }
+  #[inline]
+  pub fn add_long_enum_normal_default(&mut self, long_enum_normal_default: LongEnum) {
+    self.fbb_.push_slot::<LongEnum>(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, long_enum_normal_default, LongEnum::LongOne);
+  }
+  #[inline]
   pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MonsterBuilder<'a, 'b> {
     let start = _fbb.start_table();
     MonsterBuilder {
@@ -1435,6 +1467,8 @@ impl std::fmt::Debug for Monster<'_> {
       ds.field("testrequirednestedflatbuffer", &self.testrequirednestedflatbuffer());
       ds.field("scalar_key_sorted_tables", &self.scalar_key_sorted_tables());
       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.finish()
   }
 }
@@ -1489,6 +1523,8 @@ pub struct MonsterT {
   pub testrequirednestedflatbuffer: Option<Vec<u8>>,
   pub scalar_key_sorted_tables: Option<Vec<StatT>>,
   pub native_inline: Option<TestT>,
+  pub long_enum_non_enum_default: LongEnum,
+  pub long_enum_normal_default: LongEnum,
 }
 impl Default for MonsterT {
   fn default() -> Self {
@@ -1541,6 +1577,8 @@ impl Default for MonsterT {
       testrequirednestedflatbuffer: None,
       scalar_key_sorted_tables: None,
       native_inline: None,
+      long_enum_non_enum_default: Default::default(),
+      long_enum_normal_default: LongEnum::LongOne,
     }
   }
 }
@@ -1651,6 +1689,8 @@ impl MonsterT {
     });
     let native_inline_tmp = self.native_inline.as_ref().map(|x| x.pack());
     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;
     Monster::create(_fbb, &MonsterArgs{
       pos,
       mana,
@@ -1703,6 +1743,8 @@ impl MonsterT {
       testrequirednestedflatbuffer,
       scalar_key_sorted_tables,
       native_inline,
+      long_enum_non_enum_default,
+      long_enum_normal_default,
     })
   }
 }