Default strings and vectors: Parser + Rust support (#6421)

* Fix tests.cpp

* Parser support for vector/string defaults

* tests and default empty vectors

* addressed comments

* Default strings and vectors for Rust

* Tested Rust more_defaults

* git-clang-format

* add more_defaults_test

* fixed vector default

* removed commented out code

* more unreachable

Co-authored-by: Casper Neo <cneo@google.com>

tests/generate_code.sh

@@ -61,6 +61,9 @@ $TEST_NOINCL_FLAGS $TEST_CPP_FLAGS $TEST_CS_FLAGS $TEST_JS_TS_FLAGS -o namespace
 ../flatc --csharp --rust --gen-object-api optional_scalars.fbs
 ../flatc $TEST_NOINCL_FLAGS $TEST_CPP_FLAGS --cpp optional_scalars.fbs
 
+# Generate string/vector default code for tests
+../flatc --rust --gen-object-api more_defaults.fbs
+
 # Generate the schema evolution tests
 ../flatc --cpp --scoped-enums $TEST_CPP_FLAGS -o evolution_test ./evolution_test/evolution_v*.fbs
 

tests/monster_test_generated.rs

@@ -3197,7 +3197,7 @@ impl Default for MonsterT {
       pos: None,
       mana: 150,
       hp: 100,
-      name: String::new(),
+      name: "".to_string(),
       inventory: None,
       color: Color::Blue,
       test: AnyT::NONE,

tests/more_defaults.fbs

@@ -0,0 +1,7 @@
+
+table MoreDefaults {
+  ints: [int] = [];
+  floats: [float] = [     ];
+  empty_string: string = "";
+  some_string: string = "some";
+}

tests/more_defaults_generated.rs

@@ -0,0 +1,214 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+
+use std::mem;
+use std::cmp::Ordering;
+
+extern crate flatbuffers;
+use self::flatbuffers::EndianScalar;
+
+pub enum MoreDefaultsOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct MoreDefaults<'a> {
+  pub _tab: flatbuffers::Table<'a>,
+}
+
+impl<'a> flatbuffers::Follow<'a> for MoreDefaults<'a> {
+    type Inner = MoreDefaults<'a>;
+    #[inline]
+    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+        Self { _tab: flatbuffers::Table { buf, loc } }
+    }
+}
+
+impl<'a> MoreDefaults<'a> {
+    #[inline]
+    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        MoreDefaults { _tab: table }
+    }
+    #[allow(unused_mut)]
+    pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
+        _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
+        args: &'args MoreDefaultsArgs<'args>) -> flatbuffers::WIPOffset<MoreDefaults<'bldr>> {
+      let mut builder = MoreDefaultsBuilder::new(_fbb);
+      if let Some(x) = args.some_string { builder.add_some_string(x); }
+      if let Some(x) = args.empty_string { builder.add_empty_string(x); }
+      if let Some(x) = args.floats { builder.add_floats(x); }
+      if let Some(x) = args.ints { builder.add_ints(x); }
+      builder.finish()
+    }
+
+    pub fn unpack(&self) -> MoreDefaultsT {
+      let ints = {
+        let x = self.ints();
+        x.into_iter().collect()
+      };
+      let floats = {
+        let x = self.floats();
+        x.into_iter().collect()
+      };
+      let empty_string = {
+        let x = self.empty_string();
+        x.to_string()
+      };
+      let some_string = {
+        let x = self.some_string();
+        x.to_string()
+      };
+      MoreDefaultsT {
+        ints,
+        floats,
+        empty_string,
+        some_string,
+      }
+    }
+    pub const VT_INTS: flatbuffers::VOffsetT = 4;
+    pub const VT_FLOATS: flatbuffers::VOffsetT = 6;
+    pub const VT_EMPTY_STRING: flatbuffers::VOffsetT = 8;
+    pub const VT_SOME_STRING: flatbuffers::VOffsetT = 10;
+
+  #[inline]
+  pub fn ints(&self) -> flatbuffers::Vector<'a, i32> {
+    self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, i32>>>(MoreDefaults::VT_INTS, Some(Default::default())).unwrap()
+  }
+  #[inline]
+  pub fn floats(&self) -> flatbuffers::Vector<'a, f32> {
+    self._tab.get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, f32>>>(MoreDefaults::VT_FLOATS, Some(Default::default())).unwrap()
+  }
+  #[inline]
+  pub fn empty_string(&self) -> &'a str {
+    self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(MoreDefaults::VT_EMPTY_STRING, Some(&"")).unwrap()
+  }
+  #[inline]
+  pub fn some_string(&self) -> &'a str {
+    self._tab.get::<flatbuffers::ForwardsUOffset<&str>>(MoreDefaults::VT_SOME_STRING, Some(&"some")).unwrap()
+  }
+}
+
+impl flatbuffers::Verifiable for MoreDefaults<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut flatbuffers::Verifier, pos: usize
+  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
+    use self::flatbuffers::Verifiable;
+    v.visit_table(pos)?
+     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, i32>>>(&"ints", Self::VT_INTS, false)?
+     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, f32>>>(&"floats", Self::VT_FLOATS, false)?
+     .visit_field::<flatbuffers::ForwardsUOffset<&str>>(&"empty_string", Self::VT_EMPTY_STRING, false)?
+     .visit_field::<flatbuffers::ForwardsUOffset<&str>>(&"some_string", Self::VT_SOME_STRING, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct MoreDefaultsArgs<'a> {
+    pub ints: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, i32>>>,
+    pub floats: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, f32>>>,
+    pub empty_string: Option<flatbuffers::WIPOffset<&'a str>>,
+    pub some_string: Option<flatbuffers::WIPOffset<&'a str>>,
+}
+impl<'a> Default for MoreDefaultsArgs<'a> {
+    #[inline]
+    fn default() -> Self {
+        MoreDefaultsArgs {
+            ints: None,
+            floats: None,
+            empty_string: None,
+            some_string: None,
+        }
+    }
+}
+pub struct MoreDefaultsBuilder<'a: 'b, 'b> {
+  fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
+  start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+}
+impl<'a: 'b, 'b> MoreDefaultsBuilder<'a, 'b> {
+  #[inline]
+  pub fn add_ints(&mut self, ints: flatbuffers::WIPOffset<flatbuffers::Vector<'b , i32>>) {
+    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(MoreDefaults::VT_INTS, ints);
+  }
+  #[inline]
+  pub fn add_floats(&mut self, floats: flatbuffers::WIPOffset<flatbuffers::Vector<'b , f32>>) {
+    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(MoreDefaults::VT_FLOATS, floats);
+  }
+  #[inline]
+  pub fn add_empty_string(&mut self, empty_string: flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(MoreDefaults::VT_EMPTY_STRING, empty_string);
+  }
+  #[inline]
+  pub fn add_some_string(&mut self, some_string: flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(MoreDefaults::VT_SOME_STRING, some_string);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MoreDefaultsBuilder<'a, 'b> {
+    let start = _fbb.start_table();
+    MoreDefaultsBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> flatbuffers::WIPOffset<MoreDefaults<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl std::fmt::Debug for MoreDefaults<'_> {
+  fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    let mut ds = f.debug_struct("MoreDefaults");
+      ds.field("ints", &self.ints());
+      ds.field("floats", &self.floats());
+      ds.field("empty_string", &self.empty_string());
+      ds.field("some_string", &self.some_string());
+      ds.finish()
+  }
+}
+#[non_exhaustive]
+#[derive(Debug, Clone, PartialEq)]
+pub struct MoreDefaultsT {
+  pub ints: Vec<i32>,
+  pub floats: Vec<f32>,
+  pub empty_string: String,
+  pub some_string: String,
+}
+impl Default for MoreDefaultsT {
+  fn default() -> Self {
+    Self {
+      ints: Default::default(),
+      floats: Default::default(),
+      empty_string: "".to_string(),
+      some_string: "some".to_string(),
+    }
+  }
+}
+impl MoreDefaultsT {
+  pub fn pack<'b>(
+    &self,
+    _fbb: &mut flatbuffers::FlatBufferBuilder<'b>
+  ) -> flatbuffers::WIPOffset<MoreDefaults<'b>> {
+    let ints = Some({
+      let x = &self.ints;
+      _fbb.create_vector(x)
+    });
+    let floats = Some({
+      let x = &self.floats;
+      _fbb.create_vector(x)
+    });
+    let empty_string = Some({
+      let x = &self.empty_string;
+      _fbb.create_string(x)
+    });
+    let some_string = Some({
+      let x = &self.some_string;
+      _fbb.create_string(x)
+    });
+    MoreDefaults::create(_fbb, &MoreDefaultsArgs{
+      ints,
+      floats,
+      empty_string,
+      some_string,
+    })
+  }
+}

tests/rust_usage_test/tests/integration_test.rs

@@ -30,6 +30,7 @@ extern crate quickcheck_derive;
 
 mod flexbuffers_tests;
 mod optional_scalars_test;
+mod more_defaults_test;
 
 #[allow(dead_code, unused_imports)]
 #[path = "../../include_test/include_test1_generated.rs"]

tests/rust_usage_test/tests/more_defaults_test.rs

@@ -0,0 +1,26 @@
+#[allow(dead_code, unused_imports)]
+#[path = "../../more_defaults_generated.rs"]
+mod more_defaults_generated;
+use self::more_defaults_generated::*;
+
+#[test]
+fn object_defaults() {
+    assert_eq!(
+        MoreDefaultsT::default(),
+        MoreDefaultsT {
+            ints: Vec::new(),
+            floats: Vec::new(),
+            empty_string: "".to_string(),
+            some_string: "some".to_string(),
+        },
+    )
+}
+
+#[test]
+fn nonpresent_values() {
+    let m = flatbuffers::root::<MoreDefaults>(&[0; 4]).unwrap();
+    assert_eq!(m.ints().len(), 0);
+    assert_eq!(m.floats().len(), 0);
+    assert_eq!(m.empty_string(), "");
+    assert_eq!(m.some_string(), "some");
+}

tests/test.cpp

@@ -204,7 +204,6 @@ flatbuffers::DetachedBuffer CreateFlatBufferTest(std::string &buffer) {
   flexbuild.Int(1234);
   flexbuild.Finish();
   auto flex = builder.CreateVector(flexbuild.GetBuffer());
-
   // Test vector of enums.
   Color colors[] = { Color_Blue, Color_Green };
   // We use this special creation function because we have an array of
@@ -1645,7 +1644,6 @@ void ErrorTest() {
   TestError("table X { Y:int; Y:int; }", "field already");
   TestError("table Y {} table X { Y:int; }", "same as table");
   TestError("struct X { Y:string; }", "only scalar");
-  TestError("table X { Y:string = \"\"; }", "default values");
   TestError("struct X { a:uint = 42; }", "default values");
   TestError("enum Y:byte { Z = 1 } table X { y:Y; }", "not part of enum");
   TestError("struct X { Y:int (deprecated); }", "deprecate");
@@ -1690,6 +1688,12 @@ void ErrorTest() {
             "may contain only scalar or struct fields");
   // Non-snake case field names
   TestError("table X { Y: int; } root_type Y: {Y:1.0}", "snake_case");
+  // Complex defaults
+  TestError("table X { y: string = 1; }", "expecting: string");
+  TestError("table X { y: string = []; }", " Cannot assign token");
+  TestError("table X { y: [int] = [1]; }", "Expected `]`");
+  TestError("table X { y: [int] = [; }", "Expected `]`");
+  TestError("table X { y: [int] = \"\"; }", "type mismatch");
 }
 
 template<typename T>
@@ -3620,6 +3624,22 @@ void TestEmbeddedBinarySchema() {
           0);
 }
 
+void StringVectorDefaultsTest() {
+  std::vector<std::string> schemas;
+  schemas.push_back("table Monster { mana: string = \"\"; }");
+  schemas.push_back("table Monster { mana: string = \"mystr\"; }");
+  schemas.push_back("table Monster { mana: string = \"  \"; }");
+  schemas.push_back("table Monster { mana: [int] = []; }");
+  schemas.push_back("table Monster { mana: [uint] = [  ]; }");
+  schemas.push_back("table Monster { mana: [byte] = [\t\t\n]; }");
+  for (auto s = schemas.begin(); s < schemas.end(); s++) {
+    flatbuffers::Parser parser;
+    TEST_ASSERT(parser.Parse(s->c_str()));
+    const auto *mana = parser.structs_.Lookup("Monster")->fields.Lookup("mana");
+    TEST_EQ(mana->IsDefault(), true);
+  }
+}
+
 void OptionalScalarsTest() {
   // Simple schemas and a "has optional scalar" sentinal.
   std::vector<std::string> schemas;
@@ -3852,6 +3872,7 @@ int FlatBufferTests() {
   FlatbuffersSpanTest();
   FixedLengthArrayConstructorTest();
   FieldIdentifierTest();
+  StringVectorDefaultsTest();
   return 0;
 }