Bump microsoft/setup-msbuild from 2 to 3

Bumps [microsoft/setup-msbuild](https://github.com/microsoft/setup-msbuild) from 2 to 3.
- [Release notes](https://github.com/microsoft/setup-msbuild/releases)
- [Commits](https://github.com/microsoft/setup-msbuild/compare/v2...v3)

---
updated-dependencies:
- dependency-name: microsoft/setup-msbuild
  dependency-version: '3'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>

.github/CODEOWNERS

@@ -1,5 +1,5 @@
 # Default owner
-* @aardappel @dbaileychess derekbailey@google.com
+* @dbaileychess derekbailey@google.com
 
 # Prevent modification of this file
 .github/CODEOWNERS @dbaileychess derekbailey@google.com

.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"

.github/workflows/build.yml

@@ -42,7 +42,7 @@ jobs:
         chmod +x flatc
         ./flatc --version
     - name: upload build artifacts
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v7
       with:
         name: Linux flatc binary ${{ matrix.cxx }}
         path: flatc
@@ -137,7 +137,7 @@ jobs:
     steps:
     - uses: actions/checkout@v6
     - name: Add msbuild to PATH
-      uses: microsoft/setup-msbuild@v2
+      uses: microsoft/setup-msbuild@v3
     - name: cmake
       run: >
         cmake -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=Release
@@ -162,7 +162,7 @@ jobs:
     steps:
     - uses: actions/checkout@v6
     - name: Add msbuild to PATH
-      uses: microsoft/setup-msbuild@v2
+      uses: microsoft/setup-msbuild@v3
     - name: cmake
       run: cmake -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_CPP17=ON -DFLATBUFFERS_STRICT_MODE=ON .
     - name: build
@@ -170,7 +170,7 @@ jobs:
     - name: test
       run: Release\flattests.exe
     - name: upload build artifacts
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v7
       with:
         name: Windows flatc binary
         path: Release\flatc.exe
@@ -191,14 +191,13 @@ jobs:
 
   build-dotnet-windows:
     name: Build .NET Windows
-    runs-on: windows-2022-64core
+    runs-on: windows-2022
     strategy:
       matrix:
         configuration: [
           '',
           '-p:UnsafeByteBuffer=true',
-          # Fails two tests currently.
+          '-p:EnableSpanT=true,UnsafeByteBuffer=true'
-          #'-p:EnableSpanT=true,UnsafeByteBuffer=true'
           ]
     steps:
     - uses: actions/checkout@v6
@@ -209,7 +208,7 @@ jobs:
     - name: Build
       run: |
         cd tests\FlatBuffers.Test
-        dotnet new sln --force --name FlatBuffers.Test
+        dotnet new sln --force --name FlatBuffers.Test --format sln
         dotnet sln FlatBuffers.Test.sln add FlatBuffers.Test.csproj
         dotnet build -c Release ${{matrix.configuration}} FlatBuffers.Test.sln
     - name: Run net6.0
@@ -247,7 +246,7 @@ jobs:
         chmod +x Release/flatc
         Release/flatc --version
     - name: upload build artifacts
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v7
       with:
         name: Mac flatc binary Intel
         path: Release/flatc
@@ -290,7 +289,7 @@ jobs:
         chmod +x Release/flatc
         Release/flatc --version
     - name: upload build artifacts
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v7
       with:
         name: Mac flatc binary Universal
         path: Release/flatc
@@ -315,7 +314,7 @@ jobs:
    steps:
    - uses: actions/checkout@v6
    - name: set up Java
-     uses: actions/setup-java@v4
+     uses: actions/setup-java@v5
      with:
        distribution: temurin
        java-version: 17
@@ -351,7 +350,7 @@ jobs:
     steps:
     - uses: actions/checkout@v6
     - name: Add msbuild to PATH
-      uses: microsoft/setup-msbuild@v2
+      uses: microsoft/setup-msbuild@v3
     - name: cmake
       run: cmake -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=Release -DFLATBUFFERS_BUILD_CPP17=ON -DFLATBUFFERS_STRICT_MODE=ON .
     - name: build
@@ -374,7 +373,7 @@ jobs:
     - name: Run benchmarks
       run: ./flatbenchmark --benchmark_repetitions=5 --benchmark_display_aggregates_only=true --benchmark_out_format=console --benchmark_out=benchmarks/results_${{matrix.cxx}}
     - name: Upload benchmarks results
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v7
       with:
         name: Linux flatbenchmark results ${{matrix.cxx}}
         path: benchmarks/results_${{matrix.cxx}}
@@ -395,7 +394,7 @@ jobs:
     - name: Checkout
       uses: actions/checkout@v6
     - name: set up Java
-      uses: actions/setup-java@v4
+      uses: actions/setup-java@v5
       with:
         distribution: temurin
         java-version: 17
@@ -418,7 +417,7 @@ jobs:
     - name: Checkout
       uses: actions/checkout@v6
     - name: set up Java
-      uses: actions/setup-java@v4
+      uses: actions/setup-java@v5
       with:
         distribution: temurin
         java-version: 17
@@ -447,7 +446,7 @@ jobs:
 
   build-rust-windows:
     name: Build Rust Windows
-    runs-on: windows-2022-64core
+    runs-on: windows-2022
     steps:
     - uses: actions/checkout@v6
     - name: test
@@ -592,11 +591,16 @@ jobs:
     runs-on: ubuntu-24.04
     steps:
       - uses: actions/checkout@v6
+      # Explicitly use 8.5.1 until we can update or https://github.com/actions/runner-images/issues/13564 is fixed.
+      - name: Set env
+        run: >
+          echo "USE_BAZEL_VERSION=8.5.1" >> $GITHUB_ENV
       - name: bazel build
         run: >
           bazel build
           //:flatc
           //:flatbuffers
+          //tests:flatbuffers_test
       - name: bazel test
         run: >
           bazel test
@@ -633,8 +637,7 @@ jobs:
       actions: read   # To read the workflow path.
       id-token: write # To sign the provenance.
       contents: write # To add assets to a release.
-    uses: slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@v1.2.1
+    uses: slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@v2.1.0
     with:
       base64-subjects: "${{ needs.release-digests.outputs.digests }}"
       upload-assets: true # Optional: Upload to a new release
-      compile-generator: true # Workaround for https://github.com/slsa-framework/slsa-github-generator/issues/1163

.github/workflows/docs.yml

@@ -21,11 +21,11 @@ jobs:
         run: |
           git config user.name github-actions[bot]
           git config user.email 41898282+github-actions[bot]@users.noreply.github.com
-      - uses: actions/setup-python@v5
+      - uses: actions/setup-python@v6
         with:
           python-version: 3.x
       - run: echo "cache_id=$(date --utc '+%V')" >> $GITHUB_ENV 
-      - uses: actions/cache@v4
+      - uses: actions/cache@v5
         with:
           key: mkdocs-material-${{ env.cache_id }}
           path: .cache

.github/workflows/main.yml

@@ -27,7 +27,7 @@ jobs:
        language: c++
        fuzz-seconds: 60
    - name: Upload Crash
-     uses: actions/upload-artifact@v4
+     uses: actions/upload-artifact@v7
      if: failure() && steps.build.outcome == 'success'
      with:
        name: artifacts

.github/workflows/release.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v6
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@v6
         with:
           node-version: '20.x'
           registry-url: 'https://registry.npmjs.org'
@@ -30,7 +30,7 @@ jobs:
         working-directory: ./python
     steps:
       - uses: actions/checkout@v6
-      - uses: actions/setup-python@v4
+      - uses: actions/setup-python@v6
         with:
           python-version: '3.10'
 

CMake/BuildFlatBuffers.cmake

@@ -305,8 +305,7 @@ function(flatbuffers_generate_headers)
       ${FLATBUFFERS_GENERATE_HEADERS_SCHEMAS})
   add_dependencies(
     ${FLATBUFFERS_GENERATE_HEADERS_TARGET}
-    ${FLATC}
+    ${FLATC_TARGET})
-    ${FLATBUFFERS_GENERATE_HEADERS_SCHEMAS})
   target_include_directories(
     ${FLATBUFFERS_GENERATE_HEADERS_TARGET}
     INTERFACE ${generated_target_dir})

CMakeLists.txt

@@ -559,6 +559,7 @@ if(FLATBUFFERS_BUILD_TESTS)
   compile_schema_for_test(tests/64bit/evolution/v1.fbs "${FLATC_OPT_COMP}")
   compile_schema_for_test(tests/64bit/evolution/v2.fbs "${FLATC_OPT_COMP}")
   compile_schema_for_test(tests/union_underlying_type_test.fbs "${FLATC_OPT_SCOPED_ENUMS}")
+  compile_schema_for_test(tests/cross_namespace_pack_test.fbs "${FLATC_OPT_COMP}")
 
   if(FLATBUFFERS_CODE_SANITIZE)
     add_fsanitize_to_target(flattests ${FLATBUFFERS_CODE_SANITIZE})

MODULE.bazel

@@ -7,7 +7,7 @@ module(
 
 bazel_dep(
     name = "aspect_bazel_lib",
-    version = "2.11.0",
+    version = "2.14.0",
 )
 bazel_dep(
     name = "aspect_rules_esbuild",
@@ -23,16 +23,16 @@ bazel_dep(
 )
 bazel_dep(
     name = "grpc",
-    version = "1.70.1",
+    version = "1.76.0",
     repo_name = "com_github_grpc_grpc",
 )
 bazel_dep(
     name = "platforms",
-    version = "0.0.10",
+    version = "0.0.11",
 )
 bazel_dep(
     name = "rules_cc",
-    version = "0.0.16",
+    version = "0.1.1",
 )
 bazel_dep(
     name = "rules_go",
@@ -49,7 +49,8 @@ bazel_dep(
 )
 bazel_dep(
     name = "rules_swift",
-    version = "2.1.1",
+    version = "3.1.2",
+    max_compatibility_level = 3,
     repo_name = "build_bazel_rules_swift",
 )
 bazel_dep(
@@ -62,9 +63,6 @@ npm.npm_translate_lock(
     name = "flatbuffers_npm",
     npmrc = "//:.npmrc",
     pnpm_lock = "//ts:pnpm-lock.yaml",
-    # Override the Bazel package where pnpm-lock.yaml is located and link
-    # to the specified package instead.
-    root_package = "ts",
     verify_node_modules_ignored = "//:.bazelignore",
 )
 use_repo(npm, "flatbuffers_npm")

dart/lib/src/builder.dart

@@ -5,7 +5,7 @@ import 'types.dart';
 
 /// The main builder class for creation of a FlexBuffer.
 class Builder {
-  final ByteData _buffer;
+  ByteData _buffer;
   List<_StackValue> _stack = [];
   List<_StackPointer> _stackPointers = [];
   int _offset = 0;
@@ -506,6 +506,7 @@ class Builder {
     if (prevSize < size) {
       final newBuf = ByteData(size);
       newBuf.buffer.asUint8List().setAll(0, _buffer.buffer.asUint8List());
+      _buffer = newBuf;
     }
     return newOffset;
   }

dart/test/flex_builder_test.dart

@@ -318,6 +318,21 @@ void main() {
         1,
       ]);
     }
+    {
+      // Default buffer is 2048 bytes, add 2300 bytes of strings that force it
+      // to grow.
+      final s1 = 'A' * 1000;
+      final s2 = 'B' * 800;
+      final s3 = 'C' * 500;
+
+      var flx = Builder()
+        ..startVector()
+        ..addString(s1)
+        ..addString(s2)
+        ..addString(s3)
+        ..end();
+      expect(flx.finish().length, 2323);
+    }
   });
 
   test('build map', () {

docs/source/flatc.md

@@ -79,11 +79,12 @@ list of `FILES...`.
     `myschema.fbs` to JSON:
 
     ```sh
-    flatc --json myschema.fbs mydata.bin
+    flatc --json myschema.fbs -- mydata.bin
     ```
 
-    This will generate a `mydata.json` file.
+    This will generate a `mydata.json` file. If there is no
-
+    [`file_identifier`](schema.md/#file-identification-and-extension) defined
+    for this schema, you will need to use the `--raw-binary` option.
 
 ### Additional options
 

docs/source/languages/rust.md

@@ -205,6 +205,47 @@ And example of usage, for the time being, can be found in
 - Safe getters in [SafeBuffer](https://docs.rs/flatbuffers-reflection/latest/flatbuffers_reflection/struct.SafeBuffer.html),
  which does verification when constructed so you can use it for any data source
 
+## Buffer pre allocation in a latency-sensitive context
+
+In latency-sensitive applications, dynamic memory allocations can introduce unpredictable latency spikes. The `FlatBufferBuilder` internally uses several `Vec`s that may reallocate during serialization:
+
+- The backing buffer for the FlatBuffer data
+- `field_locs` for tracking field locations within tables
+- `written_vtable_revpos` for deduplicating vtables
+- `strings_pool` for shared string interning
+
+To avoid allocations during serialization, you can preallocate all internal vectors upfront using the `with_internal_capacity` constructor:
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.rs}
+    // Preallocate: 1KB buffer, 8 field locations, 16 vtables, 32 shared strings
+    let mut builder = FlatBufferBuilder::with_internal_capacity(1024, 8, 16, 32);
+
+    // All subsequent operations will not allocate (if capacities are sufficient)
+    let name = builder.create_shared_string("MyMonster");
+    // ... build your FlatBuffer ...
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+There are three variants available:
+
+- `with_internal_capacity(size, field_locs, vtables, strings)` - Creates a new builder with all capacities preallocated
+- `from_vec_with_internal_capacity(buffer, field_locs, vtables, strings)` - Reuses an existing `Vec<u8>` as the backing buffer
+- `new_in_with_internal_capacity(allocator, field_locs, vtables, strings)` - Uses a custom `Allocator` with preallocated internal vecs
+
+When combined with `reset()`, you can reuse the same builder across multiple serializations without any allocations after the initial setup:
+
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~{.rs}
+    let mut builder = FlatBufferBuilder::with_internal_capacity(1024, 8, 16, 32);
+
+    loop {
+        // Build a FlatBuffer (allocation-free if capacities are sufficient)
+        let data = build_message(&mut builder);
+        send(data);
+
+        // Reset for reuse - clears state but retains allocated capacity
+        builder.reset();
+    }
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
 ## Useful tools created by others
 
 * [flatc-rust](https://github.com/frol/flatc-rust) - FlatBuffers compiler

docs/source/schema.md

@@ -427,9 +427,6 @@ Current understood attributes:
   it won't be accessible anymore by newer code. Note that if you deprecate a
   field that was previous required, old code may fail to validate new data (when
   using the optional verifier).
-
-### `required`
-
 - `required` (on a non-scalar table field): this field must always be set. By
   default, fields do not need to be present in the binary. This is desirable, as
   it helps with forwards/backwards compatibility, and flexibility of data

docs/source/support.md

@@ -26,7 +26,7 @@ Simple mutation                | Yes    | Yes   | Yes      | Yes   | No     | No
 Reflection                     | Yes    | No    | No       | No    | No     | No    | No  | Basic  | No  | No      | No      | No     | No
 Buffer verifier                | Yes    | No    | No       | No    | No     | No    | No  | Yes    | No  | No      | No      | No     | Yes
 Native Object API              | Yes    | No    | Yes      | Yes   | Yes    | Yes   | Yes | No     | No  | Yes     | No      | No     | Yes
-Optional Scalars               | Yes    | Yes   | Yes      | No    | No     | Yes   | Yes | Yes    | No  | No      | Yes     | Yes    | Yes
+Optional Scalars               | Yes    | Yes   | Yes      | Yes   | No     | Yes   | Yes | Yes    | No  | No      | Yes     | Yes    | Yes
 Flexbuffers                    | Yes    | Yes   | ?        | ?     | ?      | ?     | ?   | ?      | ?   | ?       | ?       | Yes    | Yes
 Testing: basic                 | Yes    | Yes   | Yes      | Yes   | Yes    | Yes   | Yes | Yes    | ?   | Yes     | Yes     | Yes    | Yes
 Testing: fuzz                  | Yes    | No    | No       | Yes   | Yes    | No    | No  | No     | ?   | No      | No      | Yes    | No

docs/source/tutorial.md

@@ -1134,12 +1134,8 @@ The Builder provides multiple ways to create `vectors`.
 === "Python"
 
     ```py
-    # Create a FlatBuffer vector and prepend the weapons.
+    # Use the generated helper to create the weapons vector from offsets.
-    # Note: Since we prepend the data, prepend them in reverse order.
+    weapons = MyGame.Sample.Monster.CreateWeaponsVector(builder, [sword, axe])
-    MyGame.Sample.Monster.StartWeaponsVector(builder, 2)
-    builder.PrependUOffsetTRelative(axe)
-    builder.PrependUOffsetTRelative(sword)
-    weapons = builder.EndVector()
     ```
 
 === "Rust"
@@ -1352,16 +1348,13 @@ bit more directly.
     ```py
     # Create a `vector` representing the inventory of the Orc. Each number
     # could correspond to an item that can be claimed after he is slain.
-    # Note: Since we prepend the bytes, this loop iterates in reverse.
+    inv = MyGame.Sample.Monster.CreateInventoryVector(builder, range(0, 10))
-    MyGame.Sample.Monster.StartInventoryVector(builder, 10)
-    for i in reversed(range(0, 10)):
-        builder.PrependByte(i)
-    inv = builder.EndVector()
 
-    MyGame.Sample.Monster.StartPathVector(builder, 2)
+    path_points = [
-    MyGame.Sample.Vec3.CreateVec3(builder, 1.0, 2.0, 3.0)
+        MyGame.Sample.Vec3T(x=1.0, y=2.0, z=3.0),
-    MyGame.Sample.Vec3.CreateVec3(builder, 4.0, 5.0, 6.0)
+        MyGame.Sample.Vec3T(x=4.0, y=5.0, z=6.0),
-    path = builder.EndVector()
+    ]
+    path = MyGame.Sample.Monster.CreatePathVector(builder, path_points)
     ```
 
 === "Rust"

go/table.go

@@ -31,10 +31,25 @@ func (t *Table) String(off UOffsetT) string {
 }
 
 // ByteVector gets a byte slice from data stored inside the flatbuffer.
+// If the offset is invalid or out of bounds, returns nil to prevent crashes.
 func (t *Table) ByteVector(off UOffsetT) []byte {
+	n := UOffsetT(len(t.Bytes))
+	// Need at least SizeUOffsetT bytes to read the relative vector offset.
+	u := UOffsetT(SizeUOffsetT)
+	if n < u || off > n-u {
+		return nil
+	}
 	off += GetUOffsetT(t.Bytes[off:])
+	// Need at least SizeUOffsetT bytes to read the vector length.
+	if n < u || off > n-u {
+		return nil
+	}
 	start := off + UOffsetT(SizeUOffsetT)
 	length := GetUOffsetT(t.Bytes[off:])
+	// Avoid overflow by checking the length against the remaining buffer space.
+	if length > n-start {
+		return nil
+	}
 	return t.Bytes[start : start+length]
 }
 

goldens/py/flatbuffers/goldens/Universe.py

@@ -80,6 +80,12 @@ def UniverseStartGalaxiesVector(builder, numElems):
 def StartGalaxiesVector(builder, numElems):
     return UniverseStartGalaxiesVector(builder, numElems)
 
+def UniverseCreateGalaxiesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateGalaxiesVector(builder, data):
+    UniverseCreateGalaxiesVector(builder, data)
+
 def UniverseEnd(builder):
     return builder.EndObject()
 

goldens/rust/basic_generated.rs

@@ -2,36 +2,38 @@
 // @generated
 extern crate alloc;
 
-
 #[allow(unused_imports, dead_code)]
 pub mod flatbuffers {
+    extern crate alloc;
 
-#[allow(unused_imports, dead_code)]
+    #[allow(unused_imports, dead_code)]
-pub mod goldens {
+    pub mod goldens {
+        extern crate alloc;
 
+        pub enum GalaxyOffset {}
 
-pub enum GalaxyOffset {}
+        #[derive(Copy, Clone, PartialEq)]
-#[derive(Copy, Clone, PartialEq)]
+        pub struct Galaxy<'a> {
-
-pub struct Galaxy<'a> {
             pub _tab: ::flatbuffers::Table<'a>,
-}
+        }
 
-impl<'a> ::flatbuffers::Follow<'a> for Galaxy<'a> {
+        impl<'a> ::flatbuffers::Follow<'a> for Galaxy<'a> {
             type Inner = Galaxy<'a>;
+
             #[inline]
             unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
                 Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
             }
-}
+        }
 
-impl<'a> Galaxy<'a> {
+        impl<'a> Galaxy<'a> {
             pub const VT_NUM_STARS: ::flatbuffers::VOffsetT = 4;
 
             #[inline]
             pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
                 Galaxy { _tab: table }
             }
+
             #[allow(unused_mut)]
             pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
                 _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
@@ -50,9 +52,9 @@ impl<'a> Galaxy<'a> {
                 // which contains a valid value in this slot
                 unsafe { self._tab.get::<i64>(Galaxy::VT_NUM_STARS, Some(0)).unwrap()}
             }
-}
+        }
 
-impl ::flatbuffers::Verifiable for Galaxy<'_> {
+        impl ::flatbuffers::Verifiable for Galaxy<'_> {
             #[inline]
             fn run_verifier(
                 v: &mut ::flatbuffers::Verifier, pos: usize
@@ -62,28 +64,32 @@ impl ::flatbuffers::Verifiable for Galaxy<'_> {
                     .finish();
                 Ok(())
             }
-}
+        }
-pub struct GalaxyArgs {
+
+        pub struct GalaxyArgs {
             pub num_stars: i64,
-}
+        }
-impl<'a> Default for GalaxyArgs {
+
+        impl<'a> Default for GalaxyArgs {
             #[inline]
             fn default() -> Self {
                 GalaxyArgs {
                     num_stars: 0,
                 }
             }
-}
+        }
 
-pub struct GalaxyBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
+        pub struct GalaxyBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
             fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
             start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
-}
+        }
-impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> GalaxyBuilder<'a, 'b, A> {
+
+        impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> GalaxyBuilder<'a, 'b, A> {
             #[inline]
             pub fn add_num_stars(&mut self, num_stars: i64) {
                 self.fbb_.push_slot::<i64>(Galaxy::VT_NUM_STARS, num_stars, 0);
             }
+
             #[inline]
             pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> GalaxyBuilder<'a, 'b, A> {
                 let start = _fbb.start_table();
@@ -92,36 +98,39 @@ impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> GalaxyBuilder<'a, 'b, A> {
                     start_: start,
                 }
             }
+
             #[inline]
             pub fn finish(self) -> ::flatbuffers::WIPOffset<Galaxy<'a>> {
                 let o = self.fbb_.end_table(self.start_);
                 ::flatbuffers::WIPOffset::new(o.value())
             }
-}
+        }
 
-impl ::core::fmt::Debug for Galaxy<'_> {
+        impl ::core::fmt::Debug for Galaxy<'_> {
             fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                 let mut ds = f.debug_struct("Galaxy");
                 ds.field("num_stars", &self.num_stars());
                 ds.finish()
             }
-}
+        }
-pub enum UniverseOffset {}
-#[derive(Copy, Clone, PartialEq)]
 
-pub struct Universe<'a> {
+        pub enum UniverseOffset {}
+
+        #[derive(Copy, Clone, PartialEq)]
+        pub struct Universe<'a> {
             pub _tab: ::flatbuffers::Table<'a>,
-}
+        }
 
-impl<'a> ::flatbuffers::Follow<'a> for Universe<'a> {
+        impl<'a> ::flatbuffers::Follow<'a> for Universe<'a> {
             type Inner = Universe<'a>;
+
             #[inline]
             unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
                 Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
             }
-}
+        }
 
-impl<'a> Universe<'a> {
+        impl<'a> Universe<'a> {
             pub const VT_AGE: ::flatbuffers::VOffsetT = 4;
             pub const VT_GALAXIES: ::flatbuffers::VOffsetT = 6;
 
@@ -129,6 +138,7 @@ impl<'a> Universe<'a> {
             pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
                 Universe { _tab: table }
             }
+
             #[allow(unused_mut)]
             pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
                 _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
@@ -148,6 +158,7 @@ impl<'a> Universe<'a> {
                 // which contains a valid value in this slot
                 unsafe { self._tab.get::<f64>(Universe::VT_AGE, Some(0.0)).unwrap()}
             }
+
             #[inline]
             pub fn galaxies(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Galaxy<'a>>>> {
                 // Safety:
@@ -155,9 +166,9 @@ impl<'a> Universe<'a> {
                 // which contains a valid value in this slot
                 unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Galaxy>>>>(Universe::VT_GALAXIES, None)}
             }
-}
+        }
 
-impl ::flatbuffers::Verifiable for Universe<'_> {
+        impl ::flatbuffers::Verifiable for Universe<'_> {
             #[inline]
             fn run_verifier(
                 v: &mut ::flatbuffers::Verifier, pos: usize
@@ -168,12 +179,14 @@ impl ::flatbuffers::Verifiable for Universe<'_> {
                     .finish();
                 Ok(())
             }
-}
+        }
-pub struct UniverseArgs<'a> {
+
+        pub struct UniverseArgs<'a> {
             pub age: f64,
             pub galaxies: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Galaxy<'a>>>>>,
-}
+        }
-impl<'a> Default for UniverseArgs<'a> {
+
+        impl<'a> Default for UniverseArgs<'a> {
             #[inline]
             fn default() -> Self {
                 UniverseArgs {
@@ -181,21 +194,24 @@ impl<'a> Default for UniverseArgs<'a> {
                     galaxies: None,
                 }
             }
-}
+        }
 
-pub struct UniverseBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
+        pub struct UniverseBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
             fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
             start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
-}
+        }
-impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UniverseBuilder<'a, 'b, A> {
+
+        impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UniverseBuilder<'a, 'b, A> {
             #[inline]
             pub fn add_age(&mut self, age: f64) {
                 self.fbb_.push_slot::<f64>(Universe::VT_AGE, age, 0.0);
             }
+
             #[inline]
             pub fn add_galaxies(&mut self, galaxies: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Galaxy<'b >>>>) {
                 self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Universe::VT_GALAXIES, galaxies);
             }
+
             #[inline]
             pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> UniverseBuilder<'a, 'b, A> {
                 let start = _fbb.start_table();
@@ -204,92 +220,103 @@ impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> UniverseBuilder<'a, 'b, A> {
                     start_: start,
                 }
             }
+
             #[inline]
             pub fn finish(self) -> ::flatbuffers::WIPOffset<Universe<'a>> {
                 let o = self.fbb_.end_table(self.start_);
                 ::flatbuffers::WIPOffset::new(o.value())
             }
-}
+        }
 
-impl ::core::fmt::Debug for Universe<'_> {
+        impl ::core::fmt::Debug for Universe<'_> {
             fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                 let mut ds = f.debug_struct("Universe");
                 ds.field("age", &self.age());
                 ds.field("galaxies", &self.galaxies());
                 ds.finish()
             }
-}
+        }
-#[inline]
+
-/// Verifies that a buffer of bytes contains a `Universe`
+        /// Verifies that a buffer of bytes contains a `Universe`
-/// and returns it.
+        /// and returns it.
-/// Note that verification is still experimental and may not
+        /// Note that verification is still experimental and may not
-/// catch every error, or be maximally performant. For the
+        /// catch every error, or be maximally performant. For the
-/// previous, unchecked, behavior use
+        /// previous, unchecked, behavior use
-/// `root_as_universe_unchecked`.
+        /// `root_as_universe_unchecked`.
-pub fn root_as_universe(buf: &[u8]) -> Result<Universe<'_>, ::flatbuffers::InvalidFlatbuffer> {
+        #[inline]
+        pub fn root_as_universe(buf: &[u8]) -> Result<Universe<'_>, ::flatbuffers::InvalidFlatbuffer> {
             ::flatbuffers::root::<Universe>(buf)
-}
+        }
-#[inline]
+
-/// Verifies that a buffer of bytes contains a size prefixed
+        /// Verifies that a buffer of bytes contains a size prefixed
-/// `Universe` and returns it.
+        /// `Universe` and returns it.
-/// Note that verification is still experimental and may not
+        /// Note that verification is still experimental and may not
-/// catch every error, or be maximally performant. For the
+        /// catch every error, or be maximally performant. For the
-/// previous, unchecked, behavior use
+        /// previous, unchecked, behavior use
-/// `size_prefixed_root_as_universe_unchecked`.
+        /// `size_prefixed_root_as_universe_unchecked`.
-pub fn size_prefixed_root_as_universe(buf: &[u8]) -> Result<Universe<'_>, ::flatbuffers::InvalidFlatbuffer> {
+        #[inline]
+        pub fn size_prefixed_root_as_universe(buf: &[u8]) -> Result<Universe<'_>, ::flatbuffers::InvalidFlatbuffer> {
             ::flatbuffers::size_prefixed_root::<Universe>(buf)
-}
+        }
-#[inline]
+
-/// Verifies, with the given options, that a buffer of bytes
+        /// Verifies, with the given options, that a buffer of bytes
-/// contains a `Universe` and returns it.
+        /// contains a `Universe` and returns it.
-/// Note that verification is still experimental and may not
+        /// Note that verification is still experimental and may not
-/// catch every error, or be maximally performant. For the
+        /// catch every error, or be maximally performant. For the
-/// previous, unchecked, behavior use
+        /// previous, unchecked, behavior use
-/// `root_as_universe_unchecked`.
+        /// `root_as_universe_unchecked`.
-pub fn root_as_universe_with_opts<'b, 'o>(
+        #[inline]
+        pub fn root_as_universe_with_opts<'b, 'o>(
             opts: &'o ::flatbuffers::VerifierOptions,
             buf: &'b [u8],
-) -> Result<Universe<'b>, ::flatbuffers::InvalidFlatbuffer> {
+        ) -> Result<Universe<'b>, ::flatbuffers::InvalidFlatbuffer> {
             ::flatbuffers::root_with_opts::<Universe<'b>>(opts, buf)
-}
+        }
-#[inline]
+
-/// Verifies, with the given verifier options, that a buffer of
+        /// Verifies, with the given verifier options, that a buffer of
-/// bytes contains a size prefixed `Universe` and returns
+        /// bytes contains a size prefixed `Universe` and returns
-/// it. Note that verification is still experimental and may not
+        /// it. Note that verification is still experimental and may not
-/// catch every error, or be maximally performant. For the
+        /// catch every error, or be maximally performant. For the
-/// previous, unchecked, behavior use
+        /// previous, unchecked, behavior use
-/// `root_as_universe_unchecked`.
+        /// `root_as_universe_unchecked`.
-pub fn size_prefixed_root_as_universe_with_opts<'b, 'o>(
+        #[inline]
+        pub fn size_prefixed_root_as_universe_with_opts<'b, 'o>(
             opts: &'o ::flatbuffers::VerifierOptions,
             buf: &'b [u8],
-) -> Result<Universe<'b>, ::flatbuffers::InvalidFlatbuffer> {
+        ) -> Result<Universe<'b>, ::flatbuffers::InvalidFlatbuffer> {
             ::flatbuffers::size_prefixed_root_with_opts::<Universe<'b>>(opts, buf)
-}
+        }
-#[inline]
+
-/// Assumes, without verification, that a buffer of bytes contains a Universe and returns it.
+        /// Assumes, without verification, that a buffer of bytes contains a Universe and returns it.
-/// # Safety
+        /// # Safety
-/// Callers must trust the given bytes do indeed contain a valid `Universe`.
+        /// Callers must trust the given bytes do indeed contain a valid `Universe`.
-pub unsafe fn root_as_universe_unchecked(buf: &[u8]) -> Universe<'_> {
+        #[inline]
+        pub unsafe fn root_as_universe_unchecked(buf: &[u8]) -> Universe<'_> {
             unsafe { ::flatbuffers::root_unchecked::<Universe>(buf) }
-}
+        }
-#[inline]
+
-/// Assumes, without verification, that a buffer of bytes contains a size prefixed Universe and returns it.
+        /// Assumes, without verification, that a buffer of bytes contains a size prefixed Universe and returns it.
-/// # Safety
+        /// # Safety
-/// Callers must trust the given bytes do indeed contain a valid size prefixed `Universe`.
+        /// Callers must trust the given bytes do indeed contain a valid size prefixed `Universe`.
-pub unsafe fn size_prefixed_root_as_universe_unchecked(buf: &[u8]) -> Universe<'_> {
+        #[inline]
+        pub unsafe fn size_prefixed_root_as_universe_unchecked(buf: &[u8]) -> Universe<'_> {
             unsafe { ::flatbuffers::size_prefixed_root_unchecked::<Universe>(buf) }
-}
+        }
-#[inline]
+
-pub fn finish_universe_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
+        #[inline]
+        pub fn finish_universe_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
             fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-    root: ::flatbuffers::WIPOffset<Universe<'a>>) {
+            root: ::flatbuffers::WIPOffset<Universe<'a>>
+        ) {
             fbb.finish(root, None);
-}
+        }
 
-#[inline]
+        #[inline]
-pub fn finish_size_prefixed_universe_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, root: ::flatbuffers::WIPOffset<Universe<'a>>) {
+        pub fn finish_size_prefixed_universe_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
+            fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+            root: ::flatbuffers::WIPOffset<Universe<'a>>
+        ) {
             fbb.finish_size_prefixed(root, None);
-}
+        }
-}  // pub mod goldens
+    } // pub mod goldens
 } // pub mod flatbuffers
-

goldens/ts/flatbuffers/goldens/universe.ts

@@ -4,7 +4,7 @@
 
 import * as flatbuffers from 'flatbuffers';
 
-import { Galaxy } from '../../flatbuffers/goldens/galaxy.js';
+import { Galaxy } from './galaxy.js';
 
 
 export class Universe {

grpc/examples/swift/Greeter/Sources/Model/greeter_generated.swift

@@ -17,16 +17,14 @@ public struct models_HelloReply: FlatBufferTable, FlatbuffersVectorInitializable
   private init(_ t: Table) { _accessor = t }
   public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
 
-  private enum VTOFFSET: VOffset {
+  private struct VT {
-    case message = 4
+    static let message: VOffset = 4
-    var v: Int32 { Int32(self.rawValue) }
-    var p: VOffset { self.rawValue }
   }
 
-  public var message: String? { let o = _accessor.offset(VTOFFSET.message.v); return o == 0 ? nil : _accessor.string(at: o) }
+  public var message: String? { let o = _accessor.offset(VT.message); return o == 0 ? nil : _accessor.string(at: o) }
-  public var messageSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.message.v) }
+  public var messageSegmentArray: [UInt8]? { return _accessor.getVector(at: VT.message) }
   public static func startHelloReply(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
-  public static func add(message: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: message, at: VTOFFSET.message.p) }
+  public static func add(message: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: message, at: VT.message) }
   public static func endHelloReply(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
   public static func createHelloReply(
     _ fbb: inout FlatBufferBuilder,
@@ -39,16 +37,16 @@ public struct models_HelloReply: FlatBufferTable, FlatbuffersVectorInitializable
 
   public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
     var _v = try verifier.visitTable(at: position)
-    try _v.visit(field: VTOFFSET.message.p, fieldName: "message", required: false, type: ForwardOffset<String>.self)
+    try _v.visit(field: VT.message, fieldName: "message", required: false, type: ForwardOffset<String>.self)
     _v.finish()
   }
 }
 
 extension models_HelloReply: Encodable {
-
   enum CodingKeys: String, CodingKey {
     case message = "message"
   }
+
   public func encode(to encoder: Encoder) throws {
     var container = encoder.container(keyedBy: CodingKeys.self)
     try container.encodeIfPresent(message, forKey: .message)
@@ -64,16 +62,14 @@ public struct models_HelloRequest: FlatBufferTable, FlatbuffersVectorInitializab
   private init(_ t: Table) { _accessor = t }
   public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
 
-  private enum VTOFFSET: VOffset {
+  private struct VT {
-    case name = 4
+    static let name: VOffset = 4
-    var v: Int32 { Int32(self.rawValue) }
-    var p: VOffset { self.rawValue }
   }
 
-  public var name: String? { let o = _accessor.offset(VTOFFSET.name.v); return o == 0 ? nil : _accessor.string(at: o) }
+  public var name: String? { let o = _accessor.offset(VT.name); return o == 0 ? nil : _accessor.string(at: o) }
-  public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.name.v) }
+  public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: VT.name) }
   public static func startHelloRequest(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) }
-  public static func add(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VTOFFSET.name.p) }
+  public static func add(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VT.name) }
   public static func endHelloRequest(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
   public static func createHelloRequest(
     _ fbb: inout FlatBufferBuilder,
@@ -86,16 +82,16 @@ public struct models_HelloRequest: FlatBufferTable, FlatbuffersVectorInitializab
 
   public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
     var _v = try verifier.visitTable(at: position)
-    try _v.visit(field: VTOFFSET.name.p, fieldName: "name", required: false, type: ForwardOffset<String>.self)
+    try _v.visit(field: VT.name, fieldName: "name", required: false, type: ForwardOffset<String>.self)
     _v.finish()
   }
 }
 
 extension models_HelloRequest: Encodable {
-
   enum CodingKeys: String, CodingKey {
     case name = "name"
   }
+
   public func encode(to encoder: Encoder) throws {
     var container = encoder.container(keyedBy: CodingKeys.self)
     try container.encodeIfPresent(name, forKey: .name)

include/codegen/namer.h

@@ -91,6 +91,14 @@ class Namer {
     std::string keyword_prefix;
     // Suffix used to escape keywords. It is usually "_".
     std::string keyword_suffix;
+    // The casing used for keywords when escaping. For most languages, keywords
+    // are case sensitive. PHP is an instance where some keywords are case
+    // insensitive.
+    enum class KeywordsCasing {
+      CaseSensitive,
+      CaseInsensitive,
+    };
+    KeywordsCasing keywords_casing;
 
     // Files.
 
@@ -204,8 +212,16 @@ class Namer {
     return result;
   }
 
+  virtual std::string NormalizeKeywordCase(const std::string& name) const {
+    if (config_.keywords_casing == Config::KeywordsCasing::CaseInsensitive) {
+      return ConvertCase(name, Case::kAllLower);
+    } else {
+      return name;
+    }
+  }
+
   virtual std::string EscapeKeyword(const std::string& name) const {
-    if (keywords_.find(name) == keywords_.end()) {
+    if (keywords_.find(NormalizeKeywordCase(name)) == keywords_.end()) {
       return name;
     } else {
       return config_.keyword_prefix + name + config_.keyword_suffix;

include/codegen/python.h

@@ -26,6 +26,7 @@ static const Namer::Config kConfig = {
     /*object_suffix=*/"T",
     /*keyword_prefix=*/"",
     /*keyword_suffix=*/"_",
+    /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
     /*filenames=*/Case::kKeep,
     /*directories=*/Case::kKeep,
     /*output_path=*/"",
@@ -49,6 +50,7 @@ static const Namer::Config kStubConfig = {
     /*object_suffix=*/"T",
     /*keyword_prefix=*/"",
     /*keyword_suffix=*/"_",
+    /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
     /*filenames=*/Case::kKeep,
     /*directories=*/Case::kKeep,
     /*output_path=*/"",

include/flatbuffers/flatbuffers.h

@@ -260,15 +260,15 @@ inline const char* flatbuffers_version_string() {
     inline FLATBUFFERS_CONSTEXPR_CPP11 E operator ~ (E lhs){\
         return E(~T(lhs));\
     }\
-    inline FLATBUFFERS_CONSTEXPR_CPP11 E operator |= (E &lhs, E rhs){\
+    inline FLATBUFFERS_CONSTEXPR_CPP14 E operator |= (E &lhs, E rhs){\
         lhs = lhs | rhs;\
         return lhs;\
     }\
-    inline FLATBUFFERS_CONSTEXPR_CPP11 E operator &= (E &lhs, E rhs){\
+    inline FLATBUFFERS_CONSTEXPR_CPP14 E operator &= (E &lhs, E rhs){\
         lhs = lhs & rhs;\
         return lhs;\
     }\
-    inline FLATBUFFERS_CONSTEXPR_CPP11 E operator ^= (E &lhs, E rhs){\
+    inline FLATBUFFERS_CONSTEXPR_CPP14 E operator ^= (E &lhs, E rhs){\
         lhs = lhs ^ rhs;\
         return lhs;\
     }\

include/flatbuffers/idl.h

@@ -223,7 +223,7 @@ struct Type {
   uint16_t fixed_length;  // only set if t == BASE_TYPE_ARRAY
 };
 
-// Represents a parsed scalar value, it's type, and field offset.
+// Represents a parsed scalar value, its type, and field offset.
 struct Value {
   Value()
       : constant("0"),
@@ -395,13 +395,20 @@ struct FieldDef : public Definition {
 };
 
 struct StructDef : public Definition {
+  enum class CycleStatus {
+    NotChecked,
+    InProgress,
+    Checked,
+  };
+
   StructDef()
       : fixed(false),
         predecl(true),
         sortbysize(true),
         has_key(false),
         minalign(1),
-        bytesize(0) {}
+        bytesize(0),
+        cycle_status{CycleStatus::NotChecked} {}
 
   void PadLastField(size_t min_align) {
     auto padding = PaddingBytes(bytesize, min_align);
@@ -423,6 +430,8 @@ struct StructDef : public Definition {
   size_t minalign;  // What the whole object needs to be aligned to.
   size_t bytesize;  // Size if fixed.
 
+  CycleStatus cycle_status;  // used for determining if we have circular references
+
   flatbuffers::unique_ptr<std::string> original_location;
   std::vector<voffset_t> reserved_ids;
 };
@@ -734,6 +743,7 @@ struct IDLOptions {
   bool python_gen_numpy;
 
   bool ts_omit_entrypoint;
+  bool ts_undefined_for_optionals;
   ProtoIdGapAction proto_id_gap_action;
 
   // Possible options for the more general generator below.
@@ -860,6 +870,7 @@ struct IDLOptions {
         python_typing(false),
         python_gen_numpy(true),
         ts_omit_entrypoint(false),
+        ts_undefined_for_optionals(false),
         proto_id_gap_action(ProtoIdGapAction::WARNING),
         mini_reflect(IDLOptions::kNone),
         require_explicit_ids(false),
@@ -1099,6 +1110,8 @@ class Parser : public ParserState {
   // others includes.
   std::vector<IncludedFile> GetIncludedFiles() const;
 
+  bool HasCircularStructDependency();
+
  private:
   class ParseDepthGuard;
 

include/flatbuffers/reflection.h

@@ -30,23 +30,21 @@ namespace flatbuffers {
 
 // ------------------------- GETTERS -------------------------
 
-inline bool IsScalar(reflection::BaseType t) {
+constexpr bool IsScalar(reflection::BaseType t) {
   return t >= reflection::UType && t <= reflection::Double;
 }
-inline bool IsInteger(reflection::BaseType t) {
+constexpr bool IsInteger(reflection::BaseType t) {
   return t >= reflection::UType && t <= reflection::ULong;
 }
-inline bool IsFloat(reflection::BaseType t) {
+constexpr bool IsFloat(reflection::BaseType t) {
   return t == reflection::Float || t == reflection::Double;
 }
-inline bool IsLong(reflection::BaseType t) {
+constexpr bool IsLong(reflection::BaseType t) {
   return t == reflection::Long || t == reflection::ULong;
 }
 
-// Size of a basic type, don't use with structs.
+// This needs to correspond to the BaseType enum.
-inline size_t GetTypeSize(reflection::BaseType base_type) {
+constexpr size_t kBaseTypeSize[] = {
-  // This needs to correspond to the BaseType enum.
-  static size_t sizes[] = {
     0,  // None
     1,  // UType
     1,  // Bool
@@ -69,11 +67,15 @@ inline size_t GetTypeSize(reflection::BaseType base_type) {
     8,  // Vector64
 
     0  // MaxBaseType. This must be kept the last entry in this array.
-  };
+};
-  static_assert(sizeof(sizes) / sizeof(size_t) == reflection::MaxBaseType + 1,
+static_assert(sizeof(kBaseTypeSize) / sizeof(size_t) ==
+                  reflection::MaxBaseType + 1,
               "Size of sizes[] array does not match the count of BaseType "
               "enum values.");
-  return sizes[base_type];
+
+// Size of a basic type, don't use with structs.
+constexpr size_t GetTypeSize(reflection::BaseType base_type) {
+  return kBaseTypeSize[base_type];
 }
 
 // Same as above, but now correctly returns the size of a struct if
@@ -420,7 +422,7 @@ pointer_inside_vector<T, U> piv(T* ptr, std::vector<U>& vec) {
   return pointer_inside_vector<T, U>(ptr, vec);
 }
 
-inline const char* UnionTypeFieldSuffix() { return "_type"; }
+constexpr const char* UnionTypeFieldSuffix() { return "_type"; }
 
 // Helper to figure out the actual table type a union refers to.
 inline const reflection::Object& GetUnionType(

kotlin/flatbuffers-kotlin/src/nativeMain/kotlin/com/google/flatbuffers/kotlin/ByteArray.kt

@@ -14,9 +14,12 @@
  * limitations under the License.
  */
 @file:Suppress("NOTHING_TO_INLINE")
+@file:OptIn(ExperimentalNativeApi::class)
 
 package com.google.flatbuffers.kotlin
 
+import kotlin.experimental.ExperimentalNativeApi
+
 /**
  * This implementation assumes that of native macOSX64 the byte order of the implementation is
  * Little Endian.

lua/flatbuffers/builder.lua

@@ -296,25 +296,62 @@ function mt:Slot(slotnum)
     self.currentVTable[slotnum + 1] = self:Offset()
 end
 
-local function finish(self, rootTable, sizePrefix)
+local function finish(self, rootTable, sizePrefix, fileIdentifier)
     UOffsetT:EnforceNumber(rootTable)
-    self:Prep(self.minalign, sizePrefix and 8 or 4)
+    local hasFid = fileIdentifier ~= nil
-    self:PrependUOffsetTRelative(rootTable)
+    if hasFid then
+        assert(#fileIdentifier == 4, "File identifier must be exactly 4 bytes")
+    end
+
+    local fid_byte_count = (hasFid and 4 or 0)
+
+    -- alignment:
+    -- root offset (4)
+    -- optional file id (4)
+    -- optional size prefix (4)
+    self:Prep(
+        self.minalign,
+        (sizePrefix and 4 or 0) +
+        4 +
+        fid_byte_count
+    )
+
+    -- root offset (points past file identifier if present)
+    self:PrependUOffsetTRelative(rootTable + fid_byte_count)
+
+    -- file identifier
+    if hasFid then
+        for i = 4, 1, -1 do
+            self:PrependByte(string.byte(fileIdentifier, i))
+        end
+    end
+
+    -- size prefix
     if sizePrefix then
         local size = self.bytes.size - self.head
         Int32:EnforceNumber(size)
         self:PrependInt32(size)
     end
+
     self.finished = true
     return self.head
 end
 
+
 function mt:Finish(rootTable)
-    return finish(self, rootTable, false)
+    return finish(self, rootTable, false, nil)
 end
 
 function mt:FinishSizePrefixed(rootTable)
-    return finish(self, rootTable, true)
+    return finish(self, rootTable, true, nil)
+end
+
+function mt:FinishWithIdentifier(rootTable, fileIdentifier)
+    return finish(self, rootTable, false, fileIdentifier)
+end
+
+function mt:FinishSizePrefixedWithIdentifier(rootTable, fileIdentifier)
+    return finish(self, rootTable, true, fileIdentifier)
 end
 
 function mt:Prepend(flags, off)

net/FlatBuffers/FlatBufferBuilder.cs

@@ -438,7 +438,6 @@ namespace Google.FlatBuffers
             if (off > Offset)
                 throw new ArgumentException();
 
-            if (off != 0)
             off = Offset - off + sizeof(int);
             PutInt(off);
         }

net/FlatBuffers/Table.cs

@@ -65,11 +65,7 @@ namespace Google.FlatBuffers
         // Create a .NET String from UTF-8 data stored inside the flatbuffer.
         public string __string(int offset)
         {
-            int stringOffset = bb.GetInt(offset);
+            offset += bb.GetInt(offset);
-            if (stringOffset == 0)
-                return null;
-
-            offset += stringOffset;
             var len = bb.GetInt(offset);
             var startPos = offset + sizeof(int);
             return bb.GetStringUTF8(startPos, len);
@@ -150,7 +146,7 @@ namespace Google.FlatBuffers
 
             var pos = this.__vector(o);
             var len = this.__vector_len(o);
-            return bb.ToArray<T>(pos, len);
+            return bb.ToArray<T>(pos, len * ByteBuffer.SizeOf<T>());
         }
 
         // Initialize any Table-derived type to point to the union at the given offset.

pnpm-lock.yaml

@@ -343,8 +343,8 @@ packages:
     engines: {node: '>=0.4.0'}
     hasBin: true
 
-  ajv@6.12.6:
+  ajv@6.14.0:
-    resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==}
+    resolution: {integrity: sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==}
 
   ansi-styles@4.3.0:
     resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==}
@@ -483,8 +483,8 @@ packages:
     resolution: {integrity: sha512-f7ccFPK3SXFHpx15UIGyRJ/FJQctuKZ0zVuN3frBo4HnK3cay9VEW0R6yPYFHC0AgqhukPzKjq22t5DmAyqGyw==}
     engines: {node: '>=16'}
 
-  flatted@3.3.1:
+  flatted@3.4.2:
-    resolution: {integrity: sha512-X8cqMLLie7KsNUDSdzeN8FYK9rEt4Dt67OsG/DNGnYTSDBG4uFAJFBnUeiV+zCVAvwFy56IjM9sH51jVaEhNxw==}
+    resolution: {integrity: sha512-PjDse7RzhcPkIJwy5t7KPWQSZ9cAbzQXcafsetQoD7sOJRQlGikNbx7yZp2OotDnJyrDcbyRq3Ttb18iYOqkxA==}
 
   glob-parent@5.1.2:
     resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==}
@@ -571,11 +571,11 @@ packages:
     resolution: {integrity: sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==}
     engines: {node: '>=8.6'}
 
-  minimatch@3.1.2:
+  minimatch@3.1.5:
-    resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}
+    resolution: {integrity: sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==}
 
-  minimatch@9.0.5:
+  minimatch@9.0.9:
-    resolution: {integrity: sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==}
+    resolution: {integrity: sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==}
     engines: {node: '>=16 || 14 >=14.17'}
 
   ms@2.1.3:
@@ -793,7 +793,7 @@ snapshots:
     dependencies:
       '@eslint/object-schema': 2.1.6
       debug: 4.3.7
-      minimatch: 3.1.2
+      minimatch: 3.1.5
     transitivePeerDependencies:
       - supports-color
 
@@ -809,14 +809,14 @@ snapshots:
 
   '@eslint/eslintrc@3.3.1':
     dependencies:
-      ajv: 6.12.6
+      ajv: 6.14.0
       debug: 4.3.7
       espree: 10.4.0
       globals: 14.0.0
       ignore: 5.3.2
       import-fresh: 3.3.0
       js-yaml: 4.1.1
-      minimatch: 3.1.2
+      minimatch: 3.1.5
       strip-json-comments: 3.1.1
     transitivePeerDependencies:
       - supports-color
@@ -932,7 +932,7 @@ snapshots:
       debug: 4.3.7
       fast-glob: 3.3.2
       is-glob: 4.0.3
-      minimatch: 9.0.5
+      minimatch: 9.0.9
       semver: 7.6.3
       ts-api-utils: 2.1.0(typescript@5.8.3)
       typescript: 5.8.3
@@ -961,7 +961,7 @@ snapshots:
 
   acorn@8.15.0: {}
 
-  ajv@6.12.6:
+  ajv@6.14.0:
     dependencies:
       fast-deep-equal: 3.1.3
       fast-json-stable-stringify: 2.1.0
@@ -1070,7 +1070,7 @@ snapshots:
       '@humanwhocodes/retry': 0.4.3
       '@types/estree': 1.0.8
       '@types/json-schema': 7.0.15
-      ajv: 6.12.6
+      ajv: 6.14.0
       chalk: 4.1.2
       cross-spawn: 7.0.6
       debug: 4.3.7
@@ -1089,7 +1089,7 @@ snapshots:
       is-glob: 4.0.3
       json-stable-stringify-without-jsonify: 1.0.1
       lodash.merge: 4.6.2
-      minimatch: 3.1.2
+      minimatch: 3.1.5
       natural-compare: 1.4.0
       optionator: 0.9.4
     transitivePeerDependencies:
@@ -1146,10 +1146,10 @@ snapshots:
 
   flat-cache@4.0.1:
     dependencies:
-      flatted: 3.3.1
+      flatted: 3.4.2
       keyv: 4.5.4
 
-  flatted@3.3.1: {}
+  flatted@3.4.2: {}
 
   glob-parent@5.1.2:
     dependencies:
@@ -1218,11 +1218,11 @@ snapshots:
       braces: 3.0.3
       picomatch: 2.3.1
 
-  minimatch@3.1.2:
+  minimatch@3.1.5:
     dependencies:
       brace-expansion: 1.1.12
 
-  minimatch@9.0.5:
+  minimatch@9.0.9:
     dependencies:
       brace-expansion: 2.0.2
 

python/flatbuffers/builder.py

@@ -422,7 +422,6 @@ class Builder(object):
     off2 = self.Offset() - off + N.UOffsetTFlags.bytewidth
     self.PlaceUOffsetT(off2)
 
-  ## @cond FLATBUFFERS_INTERNAL
   def StartVector(self, elemSize, numElems, alignment):
     """StartVector initializes bookkeeping for writing a new vector.
 
@@ -438,8 +437,6 @@ class Builder(object):
     self.Prep(alignment, elemSize * numElems)  # In case alignment > int.
     return self.Offset()
 
-  ## @endcond
-
   def EndVector(self, numElems=None):
     """EndVector writes data necessary to finish vector construction."""
 
@@ -556,6 +553,21 @@ class Builder(object):
     self.vectorNumElems = x.size
     return self.EndVector()
 
+  def CreateVectorOfTables(self, offsets):
+    """CreateVectorOfTables writes a vector of offsets such as tables or strings.
+
+    Args:
+      offsets: Iterable of offsets returned from previous builder operations.
+               Each element should be an integer compatible with UOffsetT.
+    """
+
+    offsets = list(offsets)
+    self.StartVector(N.UOffsetTFlags.bytewidth, len(offsets),
+                     N.UOffsetTFlags.bytewidth)
+    for off in reversed(offsets):
+      self.PrependUOffsetTRelative(off)
+    return self.EndVector()
+
   ## @cond FLATBUFFERS_INTERNAL
   def assertNested(self):
     """Check that we are in the process of building an object."""

python/flatbuffers/reflection/Enum.py

@@ -155,6 +155,12 @@ def EnumStartValuesVector(builder, numElems):
 def StartValuesVector(builder, numElems):
     return EnumStartValuesVector(builder, numElems)
 
+def EnumCreateValuesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateValuesVector(builder, data):
+    return EnumCreateValuesVector(builder, data)
+
 def EnumAddIsUnion(builder, isUnion):
     builder.PrependBoolSlot(2, isUnion, 0)
 
@@ -179,6 +185,12 @@ def EnumStartAttributesVector(builder, numElems):
 def StartAttributesVector(builder, numElems):
     return EnumStartAttributesVector(builder, numElems)
 
+def EnumCreateAttributesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateAttributesVector(builder, data):
+    return EnumCreateAttributesVector(builder, data)
+
 def EnumAddDocumentation(builder, documentation):
     builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
 
@@ -191,6 +203,12 @@ def EnumStartDocumentationVector(builder, numElems):
 def StartDocumentationVector(builder, numElems):
     return EnumStartDocumentationVector(builder, numElems)
 
+def EnumCreateDocumentationVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateDocumentationVector(builder, data):
+    return EnumCreateDocumentationVector(builder, data)
+
 def EnumAddDeclarationFile(builder, declarationFile):
     builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)
 

python/flatbuffers/reflection/EnumVal.py

@@ -134,6 +134,12 @@ def EnumValStartDocumentationVector(builder, numElems):
 def StartDocumentationVector(builder, numElems):
     return EnumValStartDocumentationVector(builder, numElems)
 
+def EnumValCreateDocumentationVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateDocumentationVector(builder, data):
+    return EnumValCreateDocumentationVector(builder, data)
+
 def EnumValAddAttributes(builder, attributes):
     builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
 
@@ -146,6 +152,12 @@ def EnumValStartAttributesVector(builder, numElems):
 def StartAttributesVector(builder, numElems):
     return EnumValStartAttributesVector(builder, numElems)
 
+def EnumValCreateAttributesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateAttributesVector(builder, data):
+    return EnumValCreateAttributesVector(builder, data)
+
 def EnumValEnd(builder):
     return builder.EndObject()
 

python/flatbuffers/reflection/Field.py

@@ -235,6 +235,12 @@ def FieldStartAttributesVector(builder, numElems):
 def StartAttributesVector(builder, numElems):
     return FieldStartAttributesVector(builder, numElems)
 
+def FieldCreateAttributesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateAttributesVector(builder, data):
+    return FieldCreateAttributesVector(builder, data)
+
 def FieldAddDocumentation(builder, documentation):
     builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
 
@@ -247,6 +253,12 @@ def FieldStartDocumentationVector(builder, numElems):
 def StartDocumentationVector(builder, numElems):
     return FieldStartDocumentationVector(builder, numElems)
 
+def FieldCreateDocumentationVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateDocumentationVector(builder, data):
+    return FieldCreateDocumentationVector(builder, data)
+
 def FieldAddOptional(builder, optional):
     builder.PrependBoolSlot(11, optional, 0)
 

python/flatbuffers/reflection/Object.py

@@ -158,6 +158,12 @@ def ObjectStartFieldsVector(builder, numElems):
 def StartFieldsVector(builder, numElems):
     return ObjectStartFieldsVector(builder, numElems)
 
+def ObjectCreateFieldsVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateFieldsVector(builder, data):
+    return ObjectCreateFieldsVector(builder, data)
+
 def ObjectAddIsStruct(builder, isStruct):
     builder.PrependBoolSlot(2, isStruct, 0)
 
@@ -188,6 +194,12 @@ def ObjectStartAttributesVector(builder, numElems):
 def StartAttributesVector(builder, numElems):
     return ObjectStartAttributesVector(builder, numElems)
 
+def ObjectCreateAttributesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateAttributesVector(builder, data):
+    return ObjectCreateAttributesVector(builder, data)
+
 def ObjectAddDocumentation(builder, documentation):
     builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
 
@@ -200,6 +212,12 @@ def ObjectStartDocumentationVector(builder, numElems):
 def StartDocumentationVector(builder, numElems):
     return ObjectStartDocumentationVector(builder, numElems)
 
+def ObjectCreateDocumentationVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateDocumentationVector(builder, data):
+    return ObjectCreateDocumentationVector(builder, data)
+
 def ObjectAddDeclarationFile(builder, declarationFile):
     builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)
 

python/flatbuffers/reflection/RPCCall.py

@@ -138,6 +138,12 @@ def RPCCallStartAttributesVector(builder, numElems):
 def StartAttributesVector(builder, numElems):
     return RPCCallStartAttributesVector(builder, numElems)
 
+def RPCCallCreateAttributesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateAttributesVector(builder, data):
+    return RPCCallCreateAttributesVector(builder, data)
+
 def RPCCallAddDocumentation(builder, documentation):
     builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
 
@@ -150,6 +156,12 @@ def RPCCallStartDocumentationVector(builder, numElems):
 def StartDocumentationVector(builder, numElems):
     return RPCCallStartDocumentationVector(builder, numElems)
 
+def RPCCallCreateDocumentationVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateDocumentationVector(builder, data):
+    return RPCCallCreateDocumentationVector(builder, data)
+
 def RPCCallEnd(builder):
     return builder.EndObject()
 

python/flatbuffers/reflection/Schema.py

@@ -180,6 +180,12 @@ def SchemaStartObjectsVector(builder, numElems):
 def StartObjectsVector(builder, numElems):
     return SchemaStartObjectsVector(builder, numElems)
 
+def SchemaCreateObjectsVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateObjectsVector(builder, data):
+    return SchemaCreateObjectsVector(builder, data)
+
 def SchemaAddEnums(builder, enums):
     builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(enums), 0)
 
@@ -192,6 +198,12 @@ def SchemaStartEnumsVector(builder, numElems):
 def StartEnumsVector(builder, numElems):
     return SchemaStartEnumsVector(builder, numElems)
 
+def SchemaCreateEnumsVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateEnumsVector(builder, data):
+    return SchemaCreateEnumsVector(builder, data)
+
 def SchemaAddFileIdent(builder, fileIdent):
     builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(fileIdent), 0)
 
@@ -222,6 +234,12 @@ def SchemaStartServicesVector(builder, numElems):
 def StartServicesVector(builder, numElems):
     return SchemaStartServicesVector(builder, numElems)
 
+def SchemaCreateServicesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateServicesVector(builder, data):
+    return SchemaCreateServicesVector(builder, data)
+
 def SchemaAddAdvancedFeatures(builder, advancedFeatures):
     builder.PrependUint64Slot(6, advancedFeatures, 0)
 
@@ -240,6 +258,12 @@ def SchemaStartFbsFilesVector(builder, numElems):
 def StartFbsFilesVector(builder, numElems):
     return SchemaStartFbsFilesVector(builder, numElems)
 
+def SchemaCreateFbsFilesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateFbsFilesVector(builder, data):
+    return SchemaCreateFbsFilesVector(builder, data)
+
 def SchemaEnd(builder):
     return builder.EndObject()
 

python/flatbuffers/reflection/SchemaFile.py

@@ -84,6 +84,12 @@ def SchemaFileStartIncludedFilenamesVector(builder, numElems):
 def StartIncludedFilenamesVector(builder, numElems):
     return SchemaFileStartIncludedFilenamesVector(builder, numElems)
 
+def SchemaFileCreateIncludedFilenamesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateIncludedFilenamesVector(builder, data):
+    return SchemaFileCreateIncludedFilenamesVector(builder, data)
+
 def SchemaFileEnd(builder):
     return builder.EndObject()
 

python/flatbuffers/reflection/Service.py

@@ -137,6 +137,12 @@ def ServiceStartCallsVector(builder, numElems):
 def StartCallsVector(builder, numElems):
     return ServiceStartCallsVector(builder, numElems)
 
+def ServiceCreateCallsVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateCallsVector(builder, data):
+    return ServiceCreateCallsVector(builder, data)
+
 def ServiceAddAttributes(builder, attributes):
     builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(attributes), 0)
 
@@ -149,6 +155,12 @@ def ServiceStartAttributesVector(builder, numElems):
 def StartAttributesVector(builder, numElems):
     return ServiceStartAttributesVector(builder, numElems)
 
+def ServiceCreateAttributesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateAttributesVector(builder, data):
+    return ServiceCreateAttributesVector(builder, data)
+
 def ServiceAddDocumentation(builder, documentation):
     builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(documentation), 0)
 
@@ -161,6 +173,12 @@ def ServiceStartDocumentationVector(builder, numElems):
 def StartDocumentationVector(builder, numElems):
     return ServiceStartDocumentationVector(builder, numElems)
 
+def ServiceCreateDocumentationVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateDocumentationVector(builder, data):
+    return ServiceCreateDocumentationVector(builder, data)
+
 def ServiceAddDeclarationFile(builder, declarationFile):
     builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(declarationFile), 0)
 

python/setup.cfg

@@ -1,6 +1,2 @@
-[bdist_wheel]
-universal=1
-
 [metadata]
-license_files =
+license_files = LICENSE
-   ../LICENSE

python/setup.py

@@ -32,10 +32,8 @@ setup(
     description='The FlatBuffers serialization format for Python',
     classifiers=[
         'Intended Audience :: Developers',
-        'License :: OSI Approved :: Apache Software License',
         'Operating System :: OS Independent',
         'Programming Language :: Python',
-        'Programming Language :: Python :: 2',
         'Programming Language :: Python :: 3',
         'Topic :: Software Development :: Libraries :: Python Modules',
     ],

rust/flatbuffers/src/builder.rs

@@ -24,6 +24,9 @@ use core::marker::PhantomData;
 use core::ops::{Add, AddAssign, Deref, DerefMut, Index, IndexMut, Sub, SubAssign};
 use core::ptr::write_bytes;
 
+#[cfg(feature = "std")]
+use std::collections::HashMap;
+
 use crate::endian_scalar::emplace_scalar;
 use crate::primitives::*;
 use crate::push::{Push, PushAlignment};
@@ -139,6 +142,9 @@ pub struct FlatBufferBuilder<'fbb, A: Allocator = DefaultAllocator> {
 
     min_align: usize,
     force_defaults: bool,
+    #[cfg(feature = "std")]
+    strings_pool: HashMap<String, WIPOffset<&'fbb str>>,
+    #[cfg(not(feature = "std"))]
     strings_pool: Vec<WIPOffset<&'fbb str>>,
 
     _phantom: PhantomData<&'fbb ()>,
@@ -160,6 +166,60 @@ impl<'fbb> FlatBufferBuilder<'fbb, DefaultAllocator> {
     pub fn with_capacity(size: usize) -> Self {
         Self::from_vec(vec![0; size])
     }
+    /// Create a FlatBufferBuilder that is ready for writing, with a
+    /// ready-to-use capacity of the provided size and preallocated internal vecs.
+    ///
+    /// The maximum valid value for `size` is `FLATBUFFERS_MAX_BUFFER_SIZE`.
+    ///
+    /// # Arguments
+    ///
+    /// * `size` - The initial capacity of the backing buffer in bytes.
+    /// * `field_locs_capacity` - Preallocated capacity for the field locations vec.
+    /// * `written_vtable_revpos_capacity` - Preallocated capacity for the written vtable reverse positions vec.
+    /// * `strings_pool_capacity` - Preallocated capacity for the shared strings pool vec.
+    pub fn with_internal_capacity(
+        size: usize,
+        field_locs_capacity: usize,
+        written_vtable_revpos_capacity: usize,
+        strings_pool_capacity: usize,
+    ) -> Self {
+        Self::from_vec_with_internal_capacity(
+            vec![0; size],
+            field_locs_capacity,
+            written_vtable_revpos_capacity,
+            strings_pool_capacity,
+        )
+    }
+    /// Create a FlatBufferBuilder that is ready for writing, reusing
+    /// an existing vector and preallocated internal vecs.
+    ///
+    /// # Arguments
+    ///
+    /// * `buffer` - An existing `Vec<u8>` to reuse as the backing buffer.
+    /// * `field_locs_capacity` - Preallocated capacity for the field locations vec.
+    /// * `written_vtable_revpos_capacity` - Preallocated capacity for the written vtable reverse positions vec.
+    /// * `strings_pool_capacity` - Preallocated capacity for the shared strings pool vec.
+    pub fn from_vec_with_internal_capacity(
+        buffer: Vec<u8>,
+        field_locs_capacity: usize,
+        written_vtable_revpos_capacity: usize,
+        strings_pool_capacity: usize,
+    ) -> Self {
+        // we need to check the size here because we create the backing buffer
+        // directly, bypassing the typical way of using grow_allocator:
+        assert!(
+            buffer.len() <= FLATBUFFERS_MAX_BUFFER_SIZE,
+            "cannot initialize buffer bigger than 2 gigabytes"
+        );
+        let allocator = DefaultAllocator::from_vec(buffer);
+        Self::new_in_with_internal_capacity(
+            allocator,
+            field_locs_capacity,
+            written_vtable_revpos_capacity,
+            strings_pool_capacity,
+        )
+    }
+
     /// Create a FlatBufferBuilder that is ready for writing, reusing
     /// an existing vector.
     pub fn from_vec(buffer: Vec<u8>) -> Self {
@@ -197,12 +257,52 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
 
             min_align: 0,
             force_defaults: false,
+            #[cfg(feature = "std")]
+            strings_pool: HashMap::new(),
+            #[cfg(not(feature = "std"))]
             strings_pool: Vec::new(),
 
             _phantom: PhantomData,
         }
     }
 
+    /// Create a [`FlatBufferBuilder`] that is ready for writing with a custom [`Allocator`]
+    /// and preallocated internal vecs.
+    ///
+    /// # Arguments
+    ///
+    /// * `allocator` - A custom [`Allocator`] to use as the backing buffer.
+    /// * `field_locs_capacity` - Preallocated capacity for the field locations vec.
+    /// * `written_vtable_revpos_capacity` - Preallocated capacity for the written vtable reverse positions vec.
+    /// * `strings_pool_capacity` - Preallocated capacity for the shared strings pool vec.
+    pub fn new_in_with_internal_capacity(
+        allocator: A,
+        field_locs_capacity: usize,
+        written_vtable_revpos_capacity: usize,
+        strings_pool_capacity: usize,
+    ) -> Self {
+        let head = ReverseIndex::end();
+        FlatBufferBuilder {
+            allocator,
+            head,
+
+            field_locs: Vec::with_capacity(field_locs_capacity),
+            written_vtable_revpos: Vec::with_capacity(written_vtable_revpos_capacity),
+
+            nested: false,
+            finished: false,
+
+            min_align: 0,
+            force_defaults: false,
+            #[cfg(feature = "std")]
+            strings_pool: HashMap::with_capacity(strings_pool_capacity),
+            #[cfg(not(feature = "std"))]
+            strings_pool: Vec::with_capacity(strings_pool_capacity),
+
+            _phantom: PhantomData,
+        }
+    }
+
     /// Destroy the [`FlatBufferBuilder`], returning its [`Allocator`] and the index
     /// into it that represents the start of valid data.
     pub fn collapse_in(self) -> (A, usize) {
@@ -223,7 +323,9 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
     /// new object.
     pub fn reset(&mut self) {
         // memset only the part of the buffer that could be dirty:
-        self.allocator[self.head.range_to_end()].iter_mut().for_each(|x| *x = 0);
+        self.allocator[self.head.range_to_end()]
+            .iter_mut()
+            .for_each(|x| *x = 0);
 
         self.head = ReverseIndex::end();
         self.written_vtable_revpos.clear();
@@ -343,6 +445,31 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
         WIPOffset::new(o.value())
     }
 
+    /// Create a utf8 string, and de-duplicate if already created.
+    ///
+    /// Uses a HashMap to track previously written strings, providing O(1)
+    /// amortized lookup and insertion.
+    #[cfg(feature = "std")]
+    #[inline]
+    pub fn create_shared_string<'a: 'b, 'b>(&'a mut self, s: &'b str) -> WIPOffset<&'fbb str> {
+        self.assert_not_nested(
+            "create_shared_string can not be called when a table or vector is under construction",
+        );
+
+        if let Some(&offset) = self.strings_pool.get(s) {
+            return offset;
+        }
+
+        let address = WIPOffset::new(self.create_byte_string(s.as_bytes()).value());
+        self.strings_pool.insert(s.to_owned(), address);
+        address
+    }
+
+    /// Create a utf8 string, and de-duplicate if already created.
+    ///
+    /// Uses a sorted Vec with binary search to track previously written
+    /// strings when in `no_std` mode.
+    #[cfg(not(feature = "std"))]
     #[inline]
     pub fn create_shared_string<'a: 'b, 'b>(&'a mut self, s: &'b str) -> WIPOffset<&'fbb str> {
         self.assert_not_nested(
@@ -355,19 +482,15 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
 
         let found = self.strings_pool.binary_search_by(|offset| {
             let ptr = offset.value() as usize;
-            // Gets The pointer to the size of the string
             let str_memory = &buf[buf.len() - ptr..];
-            // Gets the size of the written string from buffer
+            let size = u32::from_le_bytes([
-            let size =
+                str_memory[0],
-                u32::from_le_bytes([str_memory[0], str_memory[1], str_memory[2], str_memory[3]])
+                str_memory[1],
-                    as usize;
+                str_memory[2],
-            // Size of the string size
+                str_memory[3],
-            let string_size: usize = 4;
+            ]) as usize;
-            // Fetches actual string bytes from index of string after string size
+            let stored = &str_memory[4..4 + size];
-            // to the size of string plus string size
+            stored.cmp(s.as_bytes())
-            let iter = str_memory[string_size..size + string_size].iter();
-            // Compares bytes of fetched string and current writable string
-            iter.cloned().cmp(s.bytes())
         });
 
         match found {
@@ -611,6 +734,8 @@ impl<'fbb, A: Allocator> FlatBufferBuilder<'fbb, A> {
         // Write the VTable (we may delete it afterwards, if it is a duplicate):
         let vt_start_pos = self.head;
         let vt_end_pos = self.head + vtable_byte_len;
+        // Zero out the vtable space - make_space only reserves but doesn't initialize
+        self.allocator[vt_start_pos.range_to(vt_end_pos)].fill(0);
         {
             // write the vtable header:
             let vtfw =
@@ -929,6 +1054,33 @@ impl<T> IndexMut<ReverseIndexRange> for [T] {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use core::sync::atomic::{AtomicUsize, Ordering};
+    use std::alloc::{GlobalAlloc, Layout, System};
+
+    static ALLOC_COUNT: AtomicUsize = AtomicUsize::new(0);
+
+    struct CountingAllocator;
+
+    unsafe impl GlobalAlloc for CountingAllocator {
+        unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+            ALLOC_COUNT.fetch_add(1, Ordering::Relaxed);
+            unsafe { System.alloc(layout) }
+        }
+        unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+            unsafe { System.dealloc(ptr, layout) }
+        }
+    }
+
+    #[global_allocator]
+    static GLOBAL: CountingAllocator = CountingAllocator;
+
+    fn reset_alloc_count() {
+        ALLOC_COUNT.store(0, Ordering::Relaxed);
+    }
+
+    fn alloc_count() -> usize {
+        ALLOC_COUNT.load(Ordering::Relaxed)
+    }
 
     #[test]
     fn reverse_index_test() {
@@ -938,4 +1090,43 @@ mod tests {
         assert_eq!(&buf[idx.range_to(idx + 1)], &[4]);
         assert_eq!(idx.to_forward_index(&buf), 4);
     }
+
+    #[test]
+    fn with_internal_capacity_preallocates_vecs() {
+        let mut builder = FlatBufferBuilder::with_internal_capacity(64, 8, 16, 32);
+
+        assert!(builder.allocator.len() >= 64);
+        assert!(builder.field_locs.capacity() >= 8);
+        assert!(builder.written_vtable_revpos.capacity() >= 16);
+        assert!(builder.strings_pool.capacity() >= 32);
+
+        assert!(builder.field_locs.is_empty());
+        assert!(builder.written_vtable_revpos.is_empty());
+        assert!(builder.strings_pool.is_empty());
+
+        // Reset the allocation counter after builder construction
+        reset_alloc_count();
+
+        // Add a shared string and verify it lands in the pool
+        let s1 = builder.create_shared_string("hello");
+        assert_eq!(builder.strings_pool.len(), 1);
+
+        // Adding the same string again should reuse the pooled entry
+        let s2 = builder.create_shared_string("hello");
+        assert_eq!(builder.strings_pool.len(), 1);
+        assert_eq!(s1.value(), s2.value());
+
+        // A different string should add a new entry
+        let _s3 = builder.create_shared_string("world");
+        assert_eq!(builder.strings_pool.len(), 2);
+
+        // With sufficient preallocated capacity, no additional allocations
+        // should have occurred for the internal vecs during the operations above
+        let allocs = alloc_count();
+        assert_eq!(
+            allocs, 0,
+            "expected 0 allocations after builder construction, got {}",
+            allocs
+        );
+    }
 }

rust/flatbuffers/src/vector.rs

@@ -107,6 +107,20 @@ impl<'a, T: Follow<'a> + 'a> Vector<'a, T> {
         key: K,
         f: fn(&<T as Follow<'a>>::Inner, &K) -> Ordering,
     ) -> Option<T::Inner> {
+        self.lookup_index_by_key(key, f).map(|idx| self.get(idx))
+    }
+
+    /// Binary search by key, returning the index of the matching element.
+    ///
+    /// This is similar to `lookup_by_key`, but returns the index of the found
+    /// element rather than the element itself. This is useful when you need
+    /// to reference elements by their position in the vector.
+    #[inline(always)]
+    pub fn lookup_index_by_key<K: Ord>(
+        &self,
+        key: K,
+        f: fn(&<T as Follow<'a>>::Inner, &K) -> Ordering,
+    ) -> Option<usize> {
         if self.is_empty() {
             return None;
         }
@@ -118,7 +132,7 @@ impl<'a, T: Follow<'a> + 'a> Vector<'a, T> {
             let mid = (left + right) / 2;
             let value = self.get(mid);
             match f(&value, &key) {
-                Ordering::Equal => return Some(value),
+                Ordering::Equal => return Some(mid),
                 Ordering::Less => left = mid + 1,
                 Ordering::Greater => {
                     if mid == 0 {

rust/flexbuffers/src/builder/ser.rs

@@ -421,6 +421,9 @@ impl<'a> Serializer for MapKeySerializer<'a> {
     type SerializeStruct = Impossible<(), Error>;
     type SerializeStructVariant = Impossible<(), Error>;
 
+    fn is_human_readable(&self) -> bool {
+        self.0.is_human_readable()
+    }
     fn serialize_bool(self, _value: bool) -> Result<(), Error> {
         key_must_be_a_string()
     }

samples/monster_generated.h

@@ -328,6 +328,10 @@ struct Monster FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
   const MyGame::Sample::Weapon *equipped_as_Weapon() const {
     return equipped_type() == MyGame::Sample::Equipment_Weapon ? static_cast<const MyGame::Sample::Weapon *>(equipped()) : nullptr;
   }
+  template<typename T> T *mutable_equipped_as();
+  MyGame::Sample::Weapon *mutable_equipped_as_Weapon() {
+    return equipped_type() == MyGame::Sample::Equipment_Weapon ? static_cast<MyGame::Sample::Weapon *>(mutable_equipped()) : nullptr;
+  }
   void *mutable_equipped() {
     return GetPointer<void *>(VT_EQUIPPED);
   }
@@ -367,6 +371,10 @@ template<> inline const MyGame::Sample::Weapon *Monster::equipped_as<MyGame::Sam
   return equipped_as_Weapon();
 }
 
+template<> inline MyGame::Sample::Weapon *Monster::mutable_equipped_as<MyGame::Sample::Weapon>() {
+  return mutable_equipped_as_Weapon();
+}
+
 struct MonsterBuilder {
   typedef Monster Table;
   ::flatbuffers::FlatBufferBuilder &fbb_;
@@ -635,7 +643,7 @@ inline ::flatbuffers::Offset<Monster> Monster::Pack(::flatbuffers::FlatBufferBui
   auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name);
   auto _inventory = _o->inventory.size() ? _fbb.CreateVector(_o->inventory) : 0;
   auto _color = _o->color;
-  auto _weapons = _o->weapons.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Sample::Weapon>> (_o->weapons.size(), [](size_t i, _VectorArgs *__va) { return CreateWeapon(*__va->__fbb, __va->__o->weapons[i].get(), __va->__rehasher); }, &_va ) : 0;
+  auto _weapons = _o->weapons.size() ? _fbb.CreateVector<::flatbuffers::Offset<MyGame::Sample::Weapon>> (_o->weapons.size(), [](size_t i, _VectorArgs *__va) { return MyGame::Sample::CreateWeapon(*__va->__fbb, __va->__o->weapons[i].get(), __va->__rehasher); }, &_va ) : 0;
   auto _equipped_type = _o->equipped.type;
   auto _equipped = _o->equipped.Pack(_fbb);
   auto _path = _o->path.size() ? _fbb.CreateVectorOfStructs(_o->path) : 0;

samples/monster_generated.swift

@@ -113,12 +113,12 @@ public struct MyGame_Sample_Vec3: NativeStruct, FlatbuffersVectorInitializable,
 }
 
 extension MyGame_Sample_Vec3: Encodable {
-
   enum CodingKeys: String, CodingKey {
     case x = "x"
     case y = "y"
     case z = "z"
   }
+
   public func encode(to encoder: Encoder) throws {
     var container = encoder.container(keyedBy: CodingKeys.self)
     if x != 0.0 {
@@ -170,51 +170,49 @@ public struct MyGame_Sample_Monster: FlatBufferTable, FlatbuffersVectorInitializ
   private init(_ t: Table) { _accessor = t }
   public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
 
-  private enum VTOFFSET: VOffset {
+  private struct VT {
-    case pos = 4
+    static let pos: VOffset = 4
-    case mana = 6
+    static let mana: VOffset = 6
-    case hp = 8
+    static let hp: VOffset = 8
-    case name = 10
+    static let name: VOffset = 10
-    case inventory = 14
+    static let inventory: VOffset = 14
-    case color = 16
+    static let color: VOffset = 16
-    case weapons = 18
+    static let weapons: VOffset = 18
-    case equippedType = 20
+    static let equippedType: VOffset = 20
-    case equipped = 22
+    static let equipped: VOffset = 22
-    case path = 24
+    static let path: VOffset = 24
-    var v: Int32 { Int32(self.rawValue) }
-    var p: VOffset { self.rawValue }
   }
 
-  public var pos: MyGame_Sample_Vec3? { let o = _accessor.offset(VTOFFSET.pos.v); return o == 0 ? nil : _accessor.readBuffer(of: MyGame_Sample_Vec3.self, at: o) }
+  public var pos: MyGame_Sample_Vec3? { let o = _accessor.offset(VT.pos); return o == 0 ? nil : _accessor.readBuffer(of: MyGame_Sample_Vec3.self, at: o) }
-  public var mutablePos: MyGame_Sample_Vec3_Mutable? { let o = _accessor.offset(VTOFFSET.pos.v); return o == 0 ? nil : MyGame_Sample_Vec3_Mutable(_accessor.bb, o: o + _accessor.position) }
+  public var mutablePos: MyGame_Sample_Vec3_Mutable? { let o = _accessor.offset(VT.pos); return o == 0 ? nil : MyGame_Sample_Vec3_Mutable(_accessor.bb, o: o + _accessor.position) }
-  public var mana: Int16 { let o = _accessor.offset(VTOFFSET.mana.v); return o == 0 ? 150 : _accessor.readBuffer(of: Int16.self, at: o) }
+  public var mana: Int16 { let o = _accessor.offset(VT.mana); return o == 0 ? 150 : _accessor.readBuffer(of: Int16.self, at: o) }
-  @discardableResult public func mutate(mana: Int16) -> Bool {let o = _accessor.offset(VTOFFSET.mana.v);  return _accessor.mutate(mana, index: o) }
+  @discardableResult public func mutate(mana: Int16) -> Bool {let o = _accessor.offset(VT.mana);  return _accessor.mutate(mana, index: o) }
-  public var hp: Int16 { let o = _accessor.offset(VTOFFSET.hp.v); return o == 0 ? 100 : _accessor.readBuffer(of: Int16.self, at: o) }
+  public var hp: Int16 { let o = _accessor.offset(VT.hp); return o == 0 ? 100 : _accessor.readBuffer(of: Int16.self, at: o) }
-  @discardableResult public func mutate(hp: Int16) -> Bool {let o = _accessor.offset(VTOFFSET.hp.v);  return _accessor.mutate(hp, index: o) }
+  @discardableResult public func mutate(hp: Int16) -> Bool {let o = _accessor.offset(VT.hp);  return _accessor.mutate(hp, index: o) }
-  public var name: String? { let o = _accessor.offset(VTOFFSET.name.v); return o == 0 ? nil : _accessor.string(at: o) }
+  public var name: String? { let o = _accessor.offset(VT.name); return o == 0 ? nil : _accessor.string(at: o) }
-  public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.name.v) }
+  public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: VT.name) }
-  public var inventory: FlatbufferVector<UInt8> { return _accessor.vector(at: VTOFFSET.inventory.v, byteSize: 1) }
+  public var inventory: FlatbufferVector<UInt8> { return _accessor.vector(at: VT.inventory, byteSize: 1) }
-  public func mutate(inventory: UInt8, at index: Int32) -> Bool { let o = _accessor.offset(VTOFFSET.inventory.v); return _accessor.directMutate(inventory, index: _accessor.vector(at: o) + index * 1) }
+  public func mutate(inventory: UInt8, at index: Int32) -> Bool { let o = _accessor.offset(VT.inventory); return _accessor.directMutate(inventory, index: _accessor.vector(at: o) + index * 1) }
-  public func withUnsafePointerToInventory<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VTOFFSET.inventory.v, body: body) }
+  public func withUnsafePointerToInventory<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.inventory, body: body) }
-  public var color: MyGame_Sample_Color { let o = _accessor.offset(VTOFFSET.color.v); return o == 0 ? .blue : MyGame_Sample_Color(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .blue }
+  public var color: MyGame_Sample_Color { let o = _accessor.offset(VT.color); return o == 0 ? .blue : MyGame_Sample_Color(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .blue }
-  @discardableResult public func mutate(color: MyGame_Sample_Color) -> Bool {let o = _accessor.offset(VTOFFSET.color.v);  return _accessor.mutate(color.rawValue, index: o) }
+  @discardableResult public func mutate(color: MyGame_Sample_Color) -> Bool {let o = _accessor.offset(VT.color);  return _accessor.mutate(color.rawValue, index: o) }
-  public var weapons: FlatbufferVector<MyGame_Sample_Weapon> { return _accessor.vector(at: VTOFFSET.weapons.v, byteSize: 4) }
+  public var weapons: FlatbufferVector<MyGame_Sample_Weapon> { return _accessor.vector(at: VT.weapons, byteSize: 4) }
-  public var equippedType: MyGame_Sample_Equipment { let o = _accessor.offset(VTOFFSET.equippedType.v); return o == 0 ? .none_ : MyGame_Sample_Equipment(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none_ }
+  public var equippedType: MyGame_Sample_Equipment { let o = _accessor.offset(VT.equippedType); return o == 0 ? .none_ : MyGame_Sample_Equipment(rawValue: _accessor.readBuffer(of: UInt8.self, at: o)) ?? .none_ }
-  public func equipped<T: FlatbuffersInitializable>(type: T.Type) -> T? { let o = _accessor.offset(VTOFFSET.equipped.v); return o == 0 ? nil : _accessor.union(o) }
+  public func equipped<T: FlatbuffersInitializable>(type: T.Type) -> T? { let o = _accessor.offset(VT.equipped); return o == 0 ? nil : _accessor.union(o) }
-  public var path: FlatbufferVector<MyGame_Sample_Vec3> { return _accessor.vector(at: VTOFFSET.path.v, byteSize: 12) }
+  public var path: FlatbufferVector<MyGame_Sample_Vec3> { return _accessor.vector(at: VT.path, byteSize: 12) }
-  public var mutablePath: FlatbufferVector<MyGame_Sample_Vec3_Mutable> { return _accessor.vector(at: VTOFFSET.path.v, byteSize: 12) }
+  public var mutablePath: FlatbufferVector<MyGame_Sample_Vec3_Mutable> { return _accessor.vector(at: VT.path, byteSize: 12) }
-  public func withUnsafePointerToPath<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VTOFFSET.path.v, body: body) }
+  public func withUnsafePointerToPath<T>(_ body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return try _accessor.withUnsafePointerToSlice(at: VT.path, body: body) }
   public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 11) }
-  public static func add(pos: MyGame_Sample_Vec3?, _ fbb: inout FlatBufferBuilder) { guard let pos = pos else { return }; fbb.create(struct: pos, position: VTOFFSET.pos.p) }
+  public static func add(pos: MyGame_Sample_Vec3?, _ fbb: inout FlatBufferBuilder) { guard let pos = pos else { return }; fbb.create(struct: pos, position: VT.pos) }
-  public static func add(mana: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: mana, def: 150, at: VTOFFSET.mana.p) }
+  public static func add(mana: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: mana, def: 150, at: VT.mana) }
-  public static func add(hp: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: hp, def: 100, at: VTOFFSET.hp.p) }
+  public static func add(hp: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: hp, def: 100, at: VT.hp) }
-  public static func add(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VTOFFSET.name.p) }
+  public static func add(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VT.name) }
-  public static func addVectorOf(inventory: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: inventory, at: VTOFFSET.inventory.p) }
+  public static func addVectorOf(inventory: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: inventory, at: VT.inventory) }
-  public static func add(color: MyGame_Sample_Color, _ fbb: inout FlatBufferBuilder) { fbb.add(element: color.rawValue, def: 2, at: VTOFFSET.color.p) }
+  public static func add(color: MyGame_Sample_Color, _ fbb: inout FlatBufferBuilder) { fbb.add(element: color.rawValue, def: 2, at: VT.color) }
-  public static func addVectorOf(weapons: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: weapons, at: VTOFFSET.weapons.p) }
+  public static func addVectorOf(weapons: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: weapons, at: VT.weapons) }
-  public static func add(equippedType: MyGame_Sample_Equipment, _ fbb: inout FlatBufferBuilder) { fbb.add(element: equippedType.rawValue, def: 0, at: VTOFFSET.equippedType.p) }
+  public static func add(equippedType: MyGame_Sample_Equipment, _ fbb: inout FlatBufferBuilder) { fbb.add(element: equippedType.rawValue, def: 0, at: VT.equippedType) }
-  public static func add(equipped: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: equipped, at: VTOFFSET.equipped.p) }
+  public static func add(equipped: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: equipped, at: VT.equipped) }
-  public static func addVectorOf(path: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: path, at: VTOFFSET.path.p) }
+  public static func addVectorOf(path: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: path, at: VT.path) }
   public static func startVectorOfPath(_ size: Int, in builder: inout FlatBufferBuilder) {
     builder.startVector(size * MemoryLayout<MyGame_Sample_Vec3>.size, elementSize: MemoryLayout<MyGame_Sample_Vec3>.alignment)
   }
@@ -293,14 +291,14 @@ public struct MyGame_Sample_Monster: FlatBufferTable, FlatbuffersVectorInitializ
 
   public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
     var _v = try verifier.visitTable(at: position)
-    try _v.visit(field: VTOFFSET.pos.p, fieldName: "pos", required: false, type: MyGame_Sample_Vec3.self)
+    try _v.visit(field: VT.pos, fieldName: "pos", required: false, type: MyGame_Sample_Vec3.self)
-    try _v.visit(field: VTOFFSET.mana.p, fieldName: "mana", required: false, type: Int16.self)
+    try _v.visit(field: VT.mana, fieldName: "mana", required: false, type: Int16.self)
-    try _v.visit(field: VTOFFSET.hp.p, fieldName: "hp", required: false, type: Int16.self)
+    try _v.visit(field: VT.hp, fieldName: "hp", required: false, type: Int16.self)
-    try _v.visit(field: VTOFFSET.name.p, fieldName: "name", required: false, type: ForwardOffset<String>.self)
+    try _v.visit(field: VT.name, fieldName: "name", required: false, type: ForwardOffset<String>.self)
-    try _v.visit(field: VTOFFSET.inventory.p, fieldName: "inventory", required: false, type: ForwardOffset<Vector<UInt8, UInt8>>.self)
+    try _v.visit(field: VT.inventory, fieldName: "inventory", required: false, type: ForwardOffset<Vector<UInt8, UInt8>>.self)
-    try _v.visit(field: VTOFFSET.color.p, fieldName: "color", required: false, type: MyGame_Sample_Color.self)
+    try _v.visit(field: VT.color, fieldName: "color", required: false, type: MyGame_Sample_Color.self)
-    try _v.visit(field: VTOFFSET.weapons.p, fieldName: "weapons", required: false, type: ForwardOffset<Vector<ForwardOffset<MyGame_Sample_Weapon>, MyGame_Sample_Weapon>>.self)
+    try _v.visit(field: VT.weapons, fieldName: "weapons", required: false, type: ForwardOffset<Vector<ForwardOffset<MyGame_Sample_Weapon>, MyGame_Sample_Weapon>>.self)
-    try _v.visit(unionKey: VTOFFSET.equippedType.p, unionField: VTOFFSET.equipped.p, unionKeyName: "equippedType", fieldName: "equipped", required: false, completion: { (verifier, key: MyGame_Sample_Equipment, pos) in
+    try _v.visit(unionKey: VT.equippedType, unionField: VT.equipped, unionKeyName: "equippedType", fieldName: "equipped", required: false, completion: { (verifier, key: MyGame_Sample_Equipment, pos) in
       switch key {
       case .none_:
         break // NOTE - SWIFT doesnt support none
@@ -308,13 +306,12 @@ public struct MyGame_Sample_Monster: FlatBufferTable, FlatbuffersVectorInitializ
         try ForwardOffset<MyGame_Sample_Weapon>.verify(&verifier, at: pos, of: MyGame_Sample_Weapon.self)
       }
     })
-    try _v.visit(field: VTOFFSET.path.p, fieldName: "path", required: false, type: ForwardOffset<Vector<MyGame_Sample_Vec3, MyGame_Sample_Vec3>>.self)
+    try _v.visit(field: VT.path, fieldName: "path", required: false, type: ForwardOffset<Vector<MyGame_Sample_Vec3, MyGame_Sample_Vec3>>.self)
     _v.finish()
   }
 }
 
 extension MyGame_Sample_Monster: Encodable {
-
   enum CodingKeys: String, CodingKey {
     case pos = "pos"
     case mana = "mana"
@@ -327,6 +324,7 @@ extension MyGame_Sample_Monster: Encodable {
     case equipped = "equipped"
     case path = "path"
   }
+
   public func encode(to encoder: Encoder) throws {
     var container = encoder.container(keyedBy: CodingKeys.self)
     try container.encodeIfPresent(pos, forKey: .pos)
@@ -411,20 +409,18 @@ public struct MyGame_Sample_Weapon: FlatBufferTable, FlatbuffersVectorInitializa
   private init(_ t: Table) { _accessor = t }
   public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
 
-  private enum VTOFFSET: VOffset {
+  private struct VT {
-    case name = 4
+    static let name: VOffset = 4
-    case damage = 6
+    static let damage: VOffset = 6
-    var v: Int32 { Int32(self.rawValue) }
-    var p: VOffset { self.rawValue }
   }
 
-  public var name: String? { let o = _accessor.offset(VTOFFSET.name.v); return o == 0 ? nil : _accessor.string(at: o) }
+  public var name: String? { let o = _accessor.offset(VT.name); return o == 0 ? nil : _accessor.string(at: o) }
-  public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: VTOFFSET.name.v) }
+  public var nameSegmentArray: [UInt8]? { return _accessor.getVector(at: VT.name) }
-  public var damage: Int16 { let o = _accessor.offset(VTOFFSET.damage.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int16.self, at: o) }
+  public var damage: Int16 { let o = _accessor.offset(VT.damage); return o == 0 ? 0 : _accessor.readBuffer(of: Int16.self, at: o) }
-  @discardableResult public func mutate(damage: Int16) -> Bool {let o = _accessor.offset(VTOFFSET.damage.v);  return _accessor.mutate(damage, index: o) }
+  @discardableResult public func mutate(damage: Int16) -> Bool {let o = _accessor.offset(VT.damage);  return _accessor.mutate(damage, index: o) }
   public static func startWeapon(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 2) }
-  public static func add(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VTOFFSET.name.p) }
+  public static func add(name: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: name, at: VT.name) }
-  public static func add(damage: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: damage, def: 0, at: VTOFFSET.damage.p) }
+  public static func add(damage: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: damage, def: 0, at: VT.damage) }
   public static func endWeapon(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end }
   public static func createWeapon(
     _ fbb: inout FlatBufferBuilder,
@@ -461,18 +457,18 @@ public struct MyGame_Sample_Weapon: FlatBufferTable, FlatbuffersVectorInitializa
 
   public static func verify<T>(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable {
     var _v = try verifier.visitTable(at: position)
-    try _v.visit(field: VTOFFSET.name.p, fieldName: "name", required: false, type: ForwardOffset<String>.self)
+    try _v.visit(field: VT.name, fieldName: "name", required: false, type: ForwardOffset<String>.self)
-    try _v.visit(field: VTOFFSET.damage.p, fieldName: "damage", required: false, type: Int16.self)
+    try _v.visit(field: VT.damage, fieldName: "damage", required: false, type: Int16.self)
     _v.finish()
   }
 }
 
 extension MyGame_Sample_Weapon: Encodable {
-
   enum CodingKeys: String, CodingKey {
     case name = "name"
     case damage = "damage"
   }
+
   public func encode(to encoder: Encoder) throws {
     var container = encoder.container(keyedBy: CodingKeys.self)
     try container.encodeIfPresent(name, forKey: .name)

samples/rust_generated/my_game/sample/color_generated.rs

@@ -2,10 +2,13 @@
 // @generated
 extern crate alloc;
 use super::*;
+
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 pub const ENUM_MIN_COLOR: i8 = 0;
+
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 pub const ENUM_MAX_COLOR: i8 = 2;
+
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 #[allow(non_camel_case_types)]
 pub const ENUM_VALUES_COLOR: [Color; 3] = [
@@ -17,6 +20,7 @@ pub const ENUM_VALUES_COLOR: [Color; 3] = [
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct Color(pub i8);
+
 #[allow(non_upper_case_globals)]
 impl Color {
     pub const Red: Self = Self(0);
@@ -30,6 +34,7 @@ impl Color {
         Self::Green,
         Self::Blue,
     ];
+
     /// Returns the variant's name or "" if unknown.
     pub fn variant_name(self) -> Option<&'static str> {
         match self {
@@ -40,6 +45,7 @@ impl Color {
         }
     }
 }
+
 impl ::core::fmt::Debug for Color {
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
         if let Some(name) = self.variant_name() {
@@ -49,8 +55,10 @@ impl ::core::fmt::Debug for Color {
         }
     }
 }
+
 impl<'a> ::flatbuffers::Follow<'a> for Color {
     type Inner = Self;
+
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         let b = unsafe { ::flatbuffers::read_scalar_at::<i8>(buf, loc) };
@@ -60,6 +68,7 @@ impl<'a> ::flatbuffers::Follow<'a> for Color {
 
 impl ::flatbuffers::Push for Color {
     type Output = Color;
+
     #[inline]
     unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
         unsafe { ::flatbuffers::emplace_scalar::<i8>(dst, self.0) };
@@ -68,10 +77,12 @@ impl ::flatbuffers::Push for Color {
 
 impl ::flatbuffers::EndianScalar for Color {
     type Scalar = i8;
+
     #[inline]
     fn to_little_endian(self) -> i8 {
         self.0.to_le()
     }
+
     #[inline]
     #[allow(clippy::wrong_self_convention)]
     fn from_little_endian(v: i8) -> Self {

samples/rust_generated/my_game/sample/equipment_generated.rs

@@ -2,10 +2,13 @@
 // @generated
 extern crate alloc;
 use super::*;
+
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 pub const ENUM_MIN_EQUIPMENT: u8 = 0;
+
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 pub const ENUM_MAX_EQUIPMENT: u8 = 1;
+
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 #[allow(non_camel_case_types)]
 pub const ENUM_VALUES_EQUIPMENT: [Equipment; 2] = [
@@ -16,6 +19,7 @@ pub const ENUM_VALUES_EQUIPMENT: [Equipment; 2] = [
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct Equipment(pub u8);
+
 #[allow(non_upper_case_globals)]
 impl Equipment {
     pub const NONE: Self = Self(0);
@@ -27,6 +31,7 @@ impl Equipment {
         Self::NONE,
         Self::Weapon,
     ];
+
     /// Returns the variant's name or "" if unknown.
     pub fn variant_name(self) -> Option<&'static str> {
         match self {
@@ -36,6 +41,7 @@ impl Equipment {
         }
     }
 }
+
 impl ::core::fmt::Debug for Equipment {
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
         if let Some(name) = self.variant_name() {
@@ -45,8 +51,10 @@ impl ::core::fmt::Debug for Equipment {
         }
     }
 }
+
 impl<'a> ::flatbuffers::Follow<'a> for Equipment {
     type Inner = Self;
+
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         let b = unsafe { ::flatbuffers::read_scalar_at::<u8>(buf, loc) };
@@ -56,6 +64,7 @@ impl<'a> ::flatbuffers::Follow<'a> for Equipment {
 
 impl ::flatbuffers::Push for Equipment {
     type Output = Equipment;
+
     #[inline]
     unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
         unsafe { ::flatbuffers::emplace_scalar::<u8>(dst, self.0) };
@@ -64,10 +73,12 @@ impl ::flatbuffers::Push for Equipment {
 
 impl ::flatbuffers::EndianScalar for Equipment {
     type Scalar = u8;
+
     #[inline]
     fn to_little_endian(self) -> u8 {
         self.0.to_le()
     }
+
     #[inline]
     #[allow(clippy::wrong_self_convention)]
     fn from_little_endian(v: u8) -> Self {
@@ -86,6 +97,7 @@ impl<'a> ::flatbuffers::Verifiable for Equipment {
 }
 
 impl ::flatbuffers::SimpleToVerifyInSlice for Equipment {}
+
 pub struct EquipmentUnionTableOffset {}
 
 #[allow(clippy::upper_case_acronyms)]
@@ -95,11 +107,13 @@ pub enum EquipmentT {
     NONE,
     Weapon(alloc::boxed::Box<WeaponT>),
 }
+
 impl Default for EquipmentT {
     fn default() -> Self {
         Self::NONE
     }
 }
+
 impl EquipmentT {
     pub fn equipment_type(&self) -> Equipment {
         match self {
@@ -107,12 +121,14 @@ impl EquipmentT {
             Self::Weapon(_) => Equipment::Weapon,
         }
     }
+
     pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>) -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>> {
         match self {
             Self::NONE => None,
             Self::Weapon(v) => Some(v.pack(fbb).as_union_value()),
         }
     }
+
     /// If the union variant matches, return the owned WeaponT, setting the union to NONE.
     pub fn take_weapon(&mut self) -> Option<alloc::boxed::Box<WeaponT>> {
         if let Self::Weapon(_) = self {
@@ -126,12 +142,15 @@ impl EquipmentT {
             None
         }
     }
+
     /// If the union variant matches, return a reference to the WeaponT.
     pub fn as_weapon(&self) -> Option<&WeaponT> {
         if let Self::Weapon(v) = self { Some(v.as_ref()) } else { None }
     }
+
     /// If the union variant matches, return a mutable reference to the WeaponT.
     pub fn as_weapon_mut(&mut self) -> Option<&mut WeaponT> {
         if let Self::Weapon(v) = self { Some(v.as_mut()) } else { None }
     }
 }
+

samples/rust_generated/my_game/sample/monster_generated.rs

@@ -2,15 +2,17 @@
 // @generated
 extern crate alloc;
 use super::*;
-pub enum MonsterOffset {}
-#[derive(Copy, Clone, PartialEq)]
 
+pub enum MonsterOffset {}
+
+#[derive(Copy, Clone, PartialEq)]
 pub struct Monster<'a> {
     pub _tab: ::flatbuffers::Table<'a>,
 }
 
 impl<'a> ::flatbuffers::Follow<'a> for Monster<'a> {
     type Inner = Monster<'a>;
+
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
@@ -37,6 +39,7 @@ impl<'a> Monster<'a> {
     pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
         Monster { _tab: table }
     }
+
     #[allow(unused_mut)]
     pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
         _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
@@ -104,6 +107,7 @@ impl<'a> Monster<'a> {
         // which contains a valid value in this slot
         unsafe { self._tab.get::<Vec3>(Monster::VT_POS, None)}
     }
+
     #[inline]
     pub fn mana(&self) -> i16 {
         // Safety:
@@ -111,6 +115,7 @@ impl<'a> Monster<'a> {
         // which contains a valid value in this slot
         unsafe { self._tab.get::<i16>(Monster::VT_MANA, Some(150)).unwrap()}
     }
+
     #[inline]
     pub fn hp(&self) -> i16 {
         // Safety:
@@ -118,6 +123,7 @@ impl<'a> Monster<'a> {
         // which contains a valid value in this slot
         unsafe { self._tab.get::<i16>(Monster::VT_HP, Some(100)).unwrap()}
     }
+
     #[inline]
     pub fn name(&self) -> Option<&'a str> {
         // Safety:
@@ -125,6 +131,7 @@ impl<'a> Monster<'a> {
         // which contains a valid value in this slot
         unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Monster::VT_NAME, None)}
     }
+
     #[inline]
     pub fn inventory(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
         // Safety:
@@ -132,6 +139,7 @@ impl<'a> Monster<'a> {
         // which contains a valid value in this slot
         unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(Monster::VT_INVENTORY, None)}
     }
+
     #[inline]
     pub fn color(&self) -> Color {
         // Safety:
@@ -139,6 +147,7 @@ impl<'a> Monster<'a> {
         // which contains a valid value in this slot
         unsafe { self._tab.get::<Color>(Monster::VT_COLOR, Some(Color::Blue)).unwrap()}
     }
+
     #[inline]
     pub fn weapons(&self) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Weapon<'a>>>> {
         // Safety:
@@ -146,6 +155,7 @@ impl<'a> Monster<'a> {
         // which contains a valid value in this slot
         unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<Weapon>>>>(Monster::VT_WEAPONS, None)}
     }
+
     #[inline]
     pub fn equipped_type(&self) -> Equipment {
         // Safety:
@@ -153,6 +163,7 @@ impl<'a> Monster<'a> {
         // which contains a valid value in this slot
         unsafe { self._tab.get::<Equipment>(Monster::VT_EQUIPPED_TYPE, Some(Equipment::NONE)).unwrap()}
     }
+
     #[inline]
     pub fn equipped(&self) -> Option<::flatbuffers::Table<'a>> {
         // Safety:
@@ -160,6 +171,7 @@ impl<'a> Monster<'a> {
         // which contains a valid value in this slot
         unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Table<'a>>>(Monster::VT_EQUIPPED, None)}
     }
+
     #[inline]
     pub fn path(&self) -> Option<::flatbuffers::Vector<'a, Vec3>> {
         // Safety:
@@ -167,6 +179,7 @@ impl<'a> Monster<'a> {
         // which contains a valid value in this slot
         unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, Vec3>>>(Monster::VT_PATH, None)}
     }
+
     #[inline]
     #[allow(non_snake_case)]
     pub fn equipped_as_weapon(&self) -> Option<Weapon<'a>> {
@@ -181,7 +194,6 @@ impl<'a> Monster<'a> {
             None
         }
     }
-
 }
 
 impl ::flatbuffers::Verifiable for Monster<'_> {
@@ -208,6 +220,7 @@ impl ::flatbuffers::Verifiable for Monster<'_> {
         Ok(())
     }
 }
+
 pub struct MonsterArgs<'a> {
     pub pos: Option<&'a Vec3>,
     pub mana: i16,
@@ -220,6 +233,7 @@ pub struct MonsterArgs<'a> {
     pub equipped: Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>,
     pub path: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, Vec3>>>,
 }
+
 impl<'a> Default for MonsterArgs<'a> {
     #[inline]
     fn default() -> Self {
@@ -242,47 +256,58 @@ pub struct MonsterBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
     fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
     start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
 }
+
 impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> MonsterBuilder<'a, 'b, A> {
     #[inline]
     pub fn add_pos(&mut self, pos: &Vec3) {
         self.fbb_.push_slot_always::<&Vec3>(Monster::VT_POS, pos);
     }
+
     #[inline]
     pub fn add_mana(&mut self, mana: i16) {
         self.fbb_.push_slot::<i16>(Monster::VT_MANA, mana, 150);
     }
+
     #[inline]
     pub fn add_hp(&mut self, hp: i16) {
         self.fbb_.push_slot::<i16>(Monster::VT_HP, hp, 100);
     }
+
     #[inline]
     pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b  str>) {
         self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_NAME, name);
     }
+
     #[inline]
     pub fn add_inventory(&mut self, inventory: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , u8>>) {
         self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_INVENTORY, inventory);
     }
+
     #[inline]
     pub fn add_color(&mut self, color: Color) {
         self.fbb_.push_slot::<Color>(Monster::VT_COLOR, color, Color::Blue);
     }
+
     #[inline]
     pub fn add_weapons(&mut self, weapons: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , ::flatbuffers::ForwardsUOffset<Weapon<'b >>>>) {
         self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_WEAPONS, weapons);
     }
+
     #[inline]
     pub fn add_equipped_type(&mut self, equipped_type: Equipment) {
         self.fbb_.push_slot::<Equipment>(Monster::VT_EQUIPPED_TYPE, equipped_type, Equipment::NONE);
     }
+
     #[inline]
     pub fn add_equipped(&mut self, equipped: ::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>) {
         self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_EQUIPPED, equipped);
     }
+
     #[inline]
     pub fn add_path(&mut self, path: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b , Vec3>>) {
         self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Monster::VT_PATH, path);
     }
+
     #[inline]
     pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> MonsterBuilder<'a, 'b, A> {
         let start = _fbb.start_table();
@@ -291,6 +316,7 @@ impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> MonsterBuilder<'a, 'b, A> {
             start_: start,
         }
     }
+
     #[inline]
     pub fn finish(self) -> ::flatbuffers::WIPOffset<Monster<'a>> {
         let o = self.fbb_.end_table(self.start_);
@@ -326,6 +352,7 @@ impl ::core::fmt::Debug for Monster<'_> {
         ds.finish()
     }
 }
+
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq)]
 pub struct MonsterT {
@@ -339,6 +366,7 @@ pub struct MonsterT {
     pub equipped: EquipmentT,
     pub path: Option<alloc::vec::Vec<Vec3T>>,
 }
+
 impl Default for MonsterT {
     fn default() -> Self {
         Self {
@@ -354,6 +382,7 @@ impl Default for MonsterT {
         }
     }
 }
+
 impl MonsterT {
     pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
         &self,
@@ -392,74 +421,85 @@ impl MonsterT {
         })
     }
 }
-#[inline]
+
 /// Verifies that a buffer of bytes contains a `Monster`
 /// and returns it.
 /// Note that verification is still experimental and may not
 /// catch every error, or be maximally performant. For the
 /// previous, unchecked, behavior use
 /// `root_as_monster_unchecked`.
+#[inline]
 pub fn root_as_monster(buf: &[u8]) -> Result<Monster<'_>, ::flatbuffers::InvalidFlatbuffer> {
     ::flatbuffers::root::<Monster>(buf)
 }
-#[inline]
+
 /// Verifies that a buffer of bytes contains a size prefixed
 /// `Monster` and returns it.
 /// Note that verification is still experimental and may not
 /// catch every error, or be maximally performant. For the
 /// previous, unchecked, behavior use
 /// `size_prefixed_root_as_monster_unchecked`.
+#[inline]
 pub fn size_prefixed_root_as_monster(buf: &[u8]) -> Result<Monster<'_>, ::flatbuffers::InvalidFlatbuffer> {
     ::flatbuffers::size_prefixed_root::<Monster>(buf)
 }
-#[inline]
+
 /// Verifies, with the given options, that a buffer of bytes
 /// contains a `Monster` and returns it.
 /// Note that verification is still experimental and may not
 /// catch every error, or be maximally performant. For the
 /// previous, unchecked, behavior use
 /// `root_as_monster_unchecked`.
+#[inline]
 pub fn root_as_monster_with_opts<'b, 'o>(
     opts: &'o ::flatbuffers::VerifierOptions,
     buf: &'b [u8],
 ) -> Result<Monster<'b>, ::flatbuffers::InvalidFlatbuffer> {
     ::flatbuffers::root_with_opts::<Monster<'b>>(opts, buf)
 }
-#[inline]
+
 /// Verifies, with the given verifier options, that a buffer of
 /// bytes contains a size prefixed `Monster` and returns
 /// it. Note that verification is still experimental and may not
 /// catch every error, or be maximally performant. For the
 /// previous, unchecked, behavior use
 /// `root_as_monster_unchecked`.
+#[inline]
 pub fn size_prefixed_root_as_monster_with_opts<'b, 'o>(
     opts: &'o ::flatbuffers::VerifierOptions,
     buf: &'b [u8],
 ) -> Result<Monster<'b>, ::flatbuffers::InvalidFlatbuffer> {
     ::flatbuffers::size_prefixed_root_with_opts::<Monster<'b>>(opts, buf)
 }
-#[inline]
+
 /// Assumes, without verification, that a buffer of bytes contains a Monster and returns it.
 /// # Safety
 /// Callers must trust the given bytes do indeed contain a valid `Monster`.
+#[inline]
 pub unsafe fn root_as_monster_unchecked(buf: &[u8]) -> Monster<'_> {
     unsafe { ::flatbuffers::root_unchecked::<Monster>(buf) }
 }
-#[inline]
+
 /// Assumes, without verification, that a buffer of bytes contains a size prefixed Monster and returns it.
 /// # Safety
 /// Callers must trust the given bytes do indeed contain a valid size prefixed `Monster`.
+#[inline]
 pub unsafe fn size_prefixed_root_as_monster_unchecked(buf: &[u8]) -> Monster<'_> {
     unsafe { ::flatbuffers::size_prefixed_root_unchecked::<Monster>(buf) }
 }
+
 #[inline]
 pub fn finish_monster_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
     fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
-    root: ::flatbuffers::WIPOffset<Monster<'a>>) {
+    root: ::flatbuffers::WIPOffset<Monster<'a>>
+) {
     fbb.finish(root, None);
 }
 
 #[inline]
-pub fn finish_size_prefixed_monster_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, root: ::flatbuffers::WIPOffset<Monster<'a>>) {
+pub fn finish_size_prefixed_monster_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
+    fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+    root: ::flatbuffers::WIPOffset<Monster<'a>>
+) {
     fbb.finish_size_prefixed(root, None);
 }

samples/rust_generated/my_game/sample/vec_3_generated.rs

@@ -2,15 +2,18 @@
 // @generated
 extern crate alloc;
 use super::*;
+
 // struct Vec3, aligned to 4
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq)]
 pub struct Vec3(pub [u8; 12]);
+
 impl Default for Vec3 {
     fn default() -> Self {
         Self([0; 12])
     }
 }
+
 impl ::core::fmt::Debug for Vec3 {
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
         f.debug_struct("Vec3")
@@ -22,27 +25,34 @@ impl ::core::fmt::Debug for Vec3 {
 }
 
 impl ::flatbuffers::SimpleToVerifyInSlice for Vec3 {}
+
 impl<'a> ::flatbuffers::Follow<'a> for Vec3 {
     type Inner = &'a Vec3;
+
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         unsafe { <&'a Vec3>::follow(buf, loc) }
     }
 }
+
 impl<'a> ::flatbuffers::Follow<'a> for &'a Vec3 {
     type Inner = &'a Vec3;
+
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         unsafe { ::flatbuffers::follow_cast_ref::<Vec3>(buf, loc) }
     }
 }
+
 impl<'b> ::flatbuffers::Push for Vec3 {
     type Output = Vec3;
+
     #[inline]
     unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
         let src = unsafe { ::core::slice::from_raw_parts(self as *const Vec3 as *const u8, <Self as ::flatbuffers::Push>::size()) };
         dst.copy_from_slice(src);
     }
+
     #[inline]
     fn alignment() -> ::flatbuffers::PushAlignment {
         ::flatbuffers::PushAlignment::new(4)
@@ -172,12 +182,22 @@ impl<'a> Vec3 {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Default)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct Vec3T {
     pub x: f32,
     pub y: f32,
     pub z: f32,
 }
+impl Default for Vec3T {
+    fn default() -> Self {
+        Self {
+            x: 0.0,
+            y: 0.0,
+            z: 0.0,
+        }
+    }
+}
+
 impl Vec3T {
     pub fn pack(&self) -> Vec3 {
         Vec3::new(
@@ -187,4 +207,3 @@ impl Vec3T {
         )
     }
 }
-

samples/rust_generated/my_game/sample/weapon_generated.rs

@@ -2,15 +2,17 @@
 // @generated
 extern crate alloc;
 use super::*;
-pub enum WeaponOffset {}
-#[derive(Copy, Clone, PartialEq)]
 
+pub enum WeaponOffset {}
+
+#[derive(Copy, Clone, PartialEq)]
 pub struct Weapon<'a> {
     pub _tab: ::flatbuffers::Table<'a>,
 }
 
 impl<'a> ::flatbuffers::Follow<'a> for Weapon<'a> {
     type Inner = Weapon<'a>;
+
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
@@ -29,6 +31,7 @@ impl<'a> Weapon<'a> {
     pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
         Weapon { _tab: table }
     }
+
     #[allow(unused_mut)]
     pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
         _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
@@ -58,6 +61,7 @@ impl<'a> Weapon<'a> {
         // which contains a valid value in this slot
         unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(Weapon::VT_NAME, None)}
     }
+
     #[inline]
     pub fn damage(&self) -> i16 {
         // Safety:
@@ -79,10 +83,12 @@ impl ::flatbuffers::Verifiable for Weapon<'_> {
         Ok(())
     }
 }
+
 pub struct WeaponArgs<'a> {
     pub name: Option<::flatbuffers::WIPOffset<&'a str>>,
     pub damage: i16,
 }
+
 impl<'a> Default for WeaponArgs<'a> {
     #[inline]
     fn default() -> Self {
@@ -97,15 +103,18 @@ pub struct WeaponBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
     fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
     start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
 }
+
 impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> WeaponBuilder<'a, 'b, A> {
     #[inline]
     pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b  str>) {
         self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(Weapon::VT_NAME, name);
     }
+
     #[inline]
     pub fn add_damage(&mut self, damage: i16) {
         self.fbb_.push_slot::<i16>(Weapon::VT_DAMAGE, damage, 0);
     }
+
     #[inline]
     pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> WeaponBuilder<'a, 'b, A> {
         let start = _fbb.start_table();
@@ -114,6 +123,7 @@ impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> WeaponBuilder<'a, 'b, A> {
             start_: start,
         }
     }
+
     #[inline]
     pub fn finish(self) -> ::flatbuffers::WIPOffset<Weapon<'a>> {
         let o = self.fbb_.end_table(self.start_);
@@ -129,12 +139,14 @@ impl ::core::fmt::Debug for Weapon<'_> {
         ds.finish()
     }
 }
+
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq)]
 pub struct WeaponT {
     pub name: Option<alloc::string::String>,
     pub damage: i16,
 }
+
 impl Default for WeaponT {
     fn default() -> Self {
         Self {
@@ -143,6 +155,7 @@ impl Default for WeaponT {
         }
     }
 }
+
 impl WeaponT {
     pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
         &self,

scripts/check_generate_code.py

@@ -33,11 +33,11 @@ result = subprocess.run(
 if result.returncode != 0:
   print(
       "\n"
-      "ERROR: *********************************************************\n"
+      "ERROR: **********************************************************\n"
       "ERROR: * The following differences were found after building.   *\n"
       "ERROR: * Perhaps there is a difference in the flags for the.    *\n"
-      "ERROR: * CMakeLists.txt vs the script/generate_code.py script? *\n"
+      "ERROR: * CMakeLists.txt vs the scripts/generate_code.py script? *\n"
-      "ERROR: *********************************************************\n"
+      "ERROR: **********************************************************\n"
   )
   subprocess.run(["git", "diff", "--binary", "--exit-code"], cwd=root_path)
   sys.exit(result.returncode)
@@ -55,11 +55,11 @@ result = subprocess.run(
 if result.returncode != 0:
   print(
       "\n"
-      "ERROR: ********************************************************\n"
+      "ERROR: *********************************************************\n"
       "ERROR: * The following differences were found after running    *\n"
-      "ERROR: * the script/generate_code.py script. Maybe you forgot *\n"
+      "ERROR: * the scripts/generate_code.py script. Maybe you forgot *\n"
       "ERROR: * to run it after making changes in a generator?        *\n"
-      "ERROR: ********************************************************\n"
+      "ERROR: *********************************************************\n"
   )
   subprocess.run(["git", "diff", "--binary", "--exit-code"], cwd=root_path)
   sys.exit(result.returncode)

scripts/generate_code.py

@@ -85,6 +85,11 @@ RUST_OPTS = BASE_OPTS + [
     "--gen-name-strings",
     "--rust-module-root-file",
 ]
+RUST_STANDALONE_OPTS = BASE_OPTS + [
+    "--rust",
+    "--gen-all",
+    "--gen-name-strings",
+]
 RUST_SERIALIZE_OPTS = BASE_OPTS + [
     "--rust",
     "--gen-all",
@@ -288,6 +293,12 @@ flatc(
     schema="include_test/include_test1.fbs",
 )
 
+flatc(
+    RUST_STANDALONE_OPTS,
+    include="include_test",
+    schema="include_test/include_test1.fbs",
+)
+
 flatc(
     RUST_OPTS,
     prefix="include_test2",
@@ -295,6 +306,12 @@ flatc(
     schema="include_test/sub/include_test2.fbs",
 )
 
+flatc(
+    RUST_STANDALONE_OPTS,
+    include="include_test",
+    schema="include_test/sub/include_test2.fbs",
+)
+
 flatc(
     BINARY_OPTS + ["--bfbs-filenames", str(tests_path)],
     include="include_test",
@@ -377,6 +394,11 @@ flatc(
     schema="native_inline_table_test.fbs",
 )
 
+flatc(
+    ["--cpp", "--gen-compare", "--gen-mutable", "--gen-object-api", "--reflect-names"],
+    schema="cross_namespace_pack_test.fbs",
+)
+
 flatc(
     RUST_OPTS,
     prefix="arrays_test",
@@ -400,6 +422,11 @@ flatc(
     schema="nested_union_test.fbs",
 )
 
+flatc(
+    ["--python", "--gen-object-api"],
+    schema="union_name_test.fbs",
+)
+
 flatc(
     NO_INCL_OPTS + CPP_OPTS,
     schema="default_vectors_strings_test.fbs",
@@ -500,6 +527,13 @@ flatc(
     cwd=swift_code_gen,
 )
 
+flatc(
+    SWIFT_OPTS_CODE_GEN + BASE_OPTS,
+    schema="empty_vtable.fbs",
+    cwd=swift_code_gen,
+    prefix="../../Tests/Flatbuffers/",
+)
+
 # Swift Wasm Tests
 swift_Wasm_prefix = "swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests"
 flatc(

src/bfbs_gen_lua.cpp

@@ -61,6 +61,7 @@ Namer::Config LuaDefaultConfig() {
           /*object_suffix=*/"",
           /*keyword_prefix=*/"",
           /*keyword_suffix=*/"_",
+          /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
           /*filenames=*/Case::kKeep,
           /*directories=*/Case::kKeep,
           /*output_path=*/"",
@@ -194,6 +195,13 @@ class LuaBfbsGenerator : public BaseBfbsGenerator {
       code += "\n";
 
       if (object == root_object) {
+        // emit file identifier if present
+        const auto ident = schema_->file_ident();
+        if (ident && ident->size() == 4) {
+          code += "local FileIdentifier = \"" + ident->str() + "\"\n";
+          code += "\n";
+        }
+
         code += "function " + object_name + ".GetRootAs" + object_name +
                 "(buf, offset)\n";
         code += "  if type(buf) == \"string\" then\n";
@@ -454,6 +462,34 @@ class LuaBfbsGenerator : public BaseBfbsGenerator {
         code += "  return builder:EndObject()\n";
         code += "end\n";
         code += "\n";
+
+        if (object == root_object) {
+          code += "function " + object_name + ".Finish" + object_name +
+                  "Buffer(builder, offset)\n";
+          // emit file identifier if present
+          const auto ident = schema_->file_ident();
+          if (ident && ident->size() == 4) {
+            code += "  builder:FinishWithIdentifier(offset, FileIdentifier)\n";
+          } else {
+            code += "  builder:Finish(offset)\n";
+          }
+          code += "end\n";
+          code += "\n";
+
+          // size prefixed option
+          code += "function " + object_name + ".FinishSizePrefixed" +
+                  object_name + "Buffer(builder, offset)\n";
+          // emit file identifier if present
+          if (ident && ident->size() == 4) {
+            code +=
+                "  builder:FinishSizePrefixedWithIdentifier(offset, "
+                "FileIdentifier)\n";
+          } else {
+            code += "  builder:FinishSizePrefixed(offset)\n";
+          }
+          code += "end\n";
+          code += "\n";
+        }
       }
 
       EmitCodeBlock(code, object_name, ns, object->declaration_file()->str());

src/bfbs_gen_nim.cpp

@@ -70,6 +70,7 @@ Namer::Config NimDefaultConfig() {
           /*object_suffix=*/"T",
           /*keyword_prefix=*/"",
           /*keyword_suffix=*/"_",
+          /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
           /*filenames=*/Case::kKeep,
           /*directories=*/Case::kKeep,
           /*output_path=*/"",

src/binary_annotator.cpp

@@ -126,9 +126,7 @@ static BinarySection GenerateMissingSection(const uint64_t offset,
 std::map<uint64_t, BinarySection> BinaryAnnotator::Annotate() {
   if (bfbs_ != nullptr && bfbs_length_ != 0) {
     flatbuffers::Verifier verifier(bfbs_, static_cast<size_t>(bfbs_length_));
-    if ((is_size_prefixed_ &&
+    if (!reflection::VerifySchemaBuffer(verifier)) {
-         !reflection::VerifySizePrefixedSchemaBuffer(verifier)) ||
-        !reflection::VerifySchemaBuffer(verifier)) {
       return {};
     }
   }

src/flatc.cpp

@@ -265,6 +265,9 @@ const static FlatCOption flatc_options[] = {
     {"", "python-gen-numpy", "", "Whether to generate numpy helpers."},
     {"", "ts-omit-entrypoint", "",
      "Omit emission of namespace entrypoint file"},
+    {"", "ts-undefined-for-optionals", "",
+     "Whether to generate undefined values instead of null values for missing "
+     "optional keys"},
     {"", "file-names-only", "",
      "Print out generated file names without writing to the files"},
     {"", "grpc-filename-suffix", "SUFFIX",
@@ -710,6 +713,8 @@ FlatCOptions FlatCompiler::ParseFromCommandLineArguments(int argc,
         opts.python_gen_numpy = false;
       } else if (arg == "--ts-omit-entrypoint") {
         opts.ts_omit_entrypoint = true;
+      } else if (arg == "--ts-undefined-for-optionals") {
+        opts.ts_undefined_for_optionals = true;
       } else if (arg == "--annotate-sparse-vectors") {
         options.annotate_include_vector_contents = false;
       } else if (arg == "--annotate") {
@@ -922,6 +927,9 @@ std::unique_ptr<Parser> FlatCompiler::GenerateCode(const FlatCOptions& options,
         auto err = parser->ConformTo(conform_parser);
         if (!err.empty()) Error("schemas don\'t conform: " + err, false);
       }
+      if (parser->HasCircularStructDependency()) {
+        Error("schema has circular struct dependencies: " + filename, false);
+      }
       if (options.schema_binary || opts.binary_schema_gen_embed) {
         parser->Serialize();
       }

src/idl_gen_cpp.cpp

@@ -2685,14 +2685,18 @@ class CppGenerator : public BaseGenerator {
     code_ += "  }";
   }
 
-  void GenTableUnionAsGetters(const FieldDef& field) {
+  void GenTableUnionAsGetters(const FieldDef& field, bool is_mutable) {
     const auto& type = field.value.type;
     auto u = type.enum_def;
 
+    code_.SetValue("MUTABLE_EXT", is_mutable ? "" : " const");
+    code_.SetValue("MUTABLE", is_mutable ? "mutable_" : "");
+
     if (!type.enum_def->uses_multiple_type_instances)
       code_ +=
-          "  template<typename T> "
+          "  template<typename T>"
-          "const T *{{NULLABLE_EXT}}{{FIELD_NAME}}_as() const;";
+          "{{MUTABLE_EXT}} T *{{MUTABLE}}{{NULLABLE_EXT}}{{FIELD_NAME}}_as()"
+          "{{MUTABLE_EXT}};";
 
     for (auto u_it = u->Vals().begin(); u_it != u->Vals().end(); ++u_it) {
       auto& ev = **u_it;
@@ -2706,15 +2710,19 @@ class CppGenerator : public BaseGenerator {
                      EscapeKeyword(Name(field) + UnionTypeFieldSuffix()));
       code_.SetValue("U_ELEMENT_TYPE", WrapInNameSpace(u->defined_namespace,
                                                        GetEnumValUse(*u, ev)));
-      code_.SetValue("U_FIELD_TYPE", "const " + full_struct_name + " *");
+      code_.SetValue("U_FIELD_TYPE",
+                     (is_mutable ? "" : "const ") + full_struct_name + " *");
       code_.SetValue("U_FIELD_NAME", Name(field) + "_as_" + Name(ev));
       code_.SetValue("U_NULLABLE", NullableExtension());
 
       // `const Type *union_name_asType() const` accessor.
-      code_ += "  {{U_FIELD_TYPE}}{{U_NULLABLE}}{{U_FIELD_NAME}}() const {";
+      // and `Type *mutable_union_name_asType()` accessor.
+      code_ +=
+          "  {{U_FIELD_TYPE}}{{U_NULLABLE}}{{MUTABLE}}{{U_FIELD_NAME}}()"
+          "{{MUTABLE_EXT}} {";
       code_ +=
           "    return {{U_GET_TYPE}}() == {{U_ELEMENT_TYPE}} ? "
-          "static_cast<{{U_FIELD_TYPE}}>({{FIELD_NAME}}()) "
+          "static_cast<{{U_FIELD_TYPE}}>({{MUTABLE}}{{FIELD_NAME}}()) "
           ": nullptr;";
       code_ += "  }";
     }
@@ -2771,15 +2779,17 @@ class CppGenerator : public BaseGenerator {
         get_call += ">(" + offset_str + ");";
         code_ += get_call;
       } else if (IsString(type) && field.value.constant != "0") {
-        // TODO: Add logic to always convert the string to a valid C++ string
+        std::string escaped;
-        // literal by handling string escapes.
+        flatbuffers::EscapeString(field.value.constant.c_str(),
+                                  field.value.constant.length(), &escaped,
+                                  true, false);
         code_ += "    auto* ptr = {{FIELD_VALUE}};";
         code_ += "    if (ptr) return ptr;";
         code_ += "    static const struct { uint32_t len; const char s[" +
                  NumToString(field.value.constant.length() + 1) +
                  "]; } bfbs_string = { " +
-                 NumToString(field.value.constant.length()) + ", \"" +
+                 NumToString(field.value.constant.length()) + ", " +
-                 field.value.constant + "\" };";
+                 escaped + " };";
         code_ +=
             "    return reinterpret_cast<const ::flatbuffers::String "
             " *>(&bfbs_string);";
@@ -2799,7 +2809,7 @@ class CppGenerator : public BaseGenerator {
     }
 
     if (type.base_type == BASE_TYPE_UNION) {
-      GenTableUnionAsGetters(field);
+      GenTableUnionAsGetters(field, false);
     }
   }
 
@@ -2974,6 +2984,11 @@ class CppGenerator : public BaseGenerator {
       auto wire_type = GenTypeGet(type, " ", "", postptr.c_str(), true);
       code_.SetValue("FIELD_TYPE", wire_type);
 
+      // mutable union accessors
+      if (type.base_type == BASE_TYPE_UNION) {
+        GenTableUnionAsGetters(field, true);
+      }
+
       if (IsVector(type) && field.value.constant == "[]") {
         const auto& vec_type = type.VectorType();
         const std::string vtype_wire = GenTypeWire(
@@ -3185,6 +3200,7 @@ class CppGenerator : public BaseGenerator {
         code_.SetValue("U_FIELD_NAME", Name(*field) + "_as_" + Name(ev));
 
         // `template<> const T *union_name_as<T>() const` accessor.
+        // and `template<> T *mutable_union_name_as<T>()` accessor.
         code_ +=
             "template<> "
             "inline {{U_FIELD_TYPE}}{{STRUCT_NAME}}::{{FIELD_NAME}}_as"
@@ -3192,6 +3208,20 @@ class CppGenerator : public BaseGenerator {
         code_ += "  return {{U_FIELD_NAME}}();";
         code_ += "}";
         code_ += "";
+
+        if (opts_.mutable_buffer) {
+          code_.SetValue("U_FIELD_TYPE", full_struct_name + " *");
+          code_.SetValue("U_FIELD_NAME",
+                         "mutable_" + Name(*field) + "_as_" + Name(ev));
+          code_ +=
+              "template<> "
+              "inline {{U_FIELD_TYPE}}"
+              "{{STRUCT_NAME}}::mutable_{{FIELD_NAME}}_as"
+              "<{{U_ELEMENT_NAME}}>() {";
+          code_ += "  return {{U_FIELD_NAME}}();";
+          code_ += "}";
+          code_ += "";
+        }
       }
     }
 
@@ -3389,11 +3419,15 @@ class CppGenerator : public BaseGenerator {
             code_.SetValue("CREATE_STRING", "CreateSharedString");
           }
           if (field->value.constant != "0") {
+            std::string escaped;
+            flatbuffers::EscapeString(field->value.constant.c_str(),
+                                      field->value.constant.length(), &escaped,
+                                      true, false);
             code_ +=
                 "  auto {{FIELD_NAME}}__ = {{FIELD_NAME}} ? "
                 "_fbb.{{CREATE_STRING}}({{FIELD_NAME}}) : "
-                "_fbb.{{CREATE_STRING}}(\"" +
+                "_fbb.{{CREATE_STRING}}(" +
-                field->value.constant + "\");";
+                escaped + ");";
           } else {
             code_ +=
                 "  auto {{FIELD_NAME}}__ = {{FIELD_NAME}} ? "
@@ -3797,7 +3831,9 @@ class CppGenerator : public BaseGenerator {
               code += WrapInNameSpace(*vector_type.struct_def) + ">> ";
               code += "(" + value + ".size(), ";
               code += "[](size_t i, _VectorArgs *__va) { ";
-              code += "return Create" + vector_type.struct_def->name;
+              code += "return " +
+                      WrapInNameSpace(vector_type.struct_def->defined_namespace,
+                                      "Create" + vector_type.struct_def->name);
               code += "(*__va->__fbb, ";
               if (field.native_inline) {
                 code += "&(__va->_" + value + "[i])";
@@ -3910,8 +3946,10 @@ class CppGenerator : public BaseGenerator {
           }
         } else {
           // _o->field ? CreateT(_fbb, _o->field.get(), _rehasher);
-          const std::string& type = field.value.type.struct_def->name;
+          const auto& nested_struct = *field.value.type.struct_def;
-          code += value + " ? Create" + type;
+          code += value + " ? " +
+                  WrapInNameSpace(nested_struct.defined_namespace,
+                                  "Create" + nested_struct.name);
           code += "(_fbb, " + value;
           if (!field.native_inline) code += GenPtrGet(field);
           code += ", _rehasher) : 0";

src/idl_gen_csharp.cpp

@@ -1243,6 +1243,58 @@ class CSharpGenerator : public BaseGenerator {
         }
         code += " }\n";
       }
+      
+      // Generate Length property and ByteBuffer accessor for arrays in structs.
+      if (IsArray(field.value.type) && struct_def.fixed &&
+          IsScalar(field.value.type.VectorType().base_type)) {
+        auto camel_name = Name(field);
+        if (camel_name == struct_def.name) { camel_name += "_"; }
+        
+        // Generate Length constant
+        code += "  public const int " + camel_name;
+        code += "Length = ";
+        code += NumToString(field.value.type.fixed_length);
+        code += ";\n";
+        
+        // Generate GetBytes methods for scalar arrays (similar to vector pattern)
+        code += "#if ENABLE_SPAN_T\n";
+        code += "  public Span<" + GenTypeBasic(field.value.type.VectorType()) +
+                "> Get";
+        code += camel_name;
+        code += "Bytes() { return ";
+        
+        // For byte arrays, we can return the span directly
+        if (field.value.type.VectorType().base_type == BASE_TYPE_UCHAR) {
+          code += "__p.bb.ToSpan(__p.bb_pos + ";
+          code += NumToString(field.value.offset);
+          code += ", ";
+          code += NumToString(field.value.type.fixed_length *
+                             SizeOf(field.value.type.VectorType().base_type));
+          code += ")";
+        } else {
+          // For other types, we need to cast the byte span
+          code += "System.Runtime.InteropServices.MemoryMarshal.Cast<byte, " +
+                  GenTypeBasic(field.value.type.VectorType()) + ">(__p.bb.ToSpan(__p.bb_pos + ";
+          code += NumToString(field.value.offset);
+          code += ", ";
+          code += NumToString(field.value.type.fixed_length *
+                             SizeOf(field.value.type.VectorType().base_type));
+          code += "))";
+        }
+        code += "; }\n";
+        code += "#else\n";
+        code += "  public ArraySegment<byte>? Get";
+        code += camel_name;
+        code += "Bytes() { return ";
+        code += "__p.bb.ToArraySegment(__p.bb_pos + ";
+        code += NumToString(field.value.offset);
+        code += ", ";
+        code += NumToString(field.value.type.fixed_length *
+                           SizeOf(field.value.type.VectorType().base_type));
+        code += ");}\n";
+        code += "#endif\n";
+      }
+      
       // generate object accessors if is nested_flatbuffer
       if (field.nested_flatbuffer) {
         auto nested_type_name = NamespacedName(*field.nested_flatbuffer);

src/idl_gen_dart.cpp

@@ -48,6 +48,7 @@ static Namer::Config DartDefaultConfig() {
           /*object_suffix=*/"T",
           /*keyword_prefix=*/"$",
           /*keyword_suffix=*/"",
+          /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
           /*filenames=*/Case::kKeep,
           /*directories=*/Case::kKeep,
           /*output_path=*/"",

src/idl_gen_fbs.cpp

@@ -368,7 +368,17 @@ static std::string GenerateFBS(const Parser& parser,
       if (field.value.type.base_type != BASE_TYPE_UTYPE) {
         GenComment(field.doc_comment, &schema, nullptr, "  ");
         schema += "  " + field.name + ":" + GenType(field.value.type);
-        if (field.value.constant != "0") schema += " = " + field.value.constant;
+        if (field.value.constant != "0") {
+          if (IsString(field.value.type)) {
+            std::string escaped;
+            flatbuffers::EscapeString(field.value.constant.c_str(),
+                                      field.value.constant.length(), &escaped,
+                                      true, false);
+            schema += " = " + escaped;
+          } else {
+            schema += " = " + field.value.constant;
+          }
+        }
         std::vector<std::string> attributes;
         if (field.IsRequired()) attributes.push_back("required");
         if (field.key) attributes.push_back("key");

src/idl_gen_go.cpp

@@ -75,6 +75,7 @@ static Namer::Config GoDefaultConfig() {
           /*object_suffix=*/"T",
           /*keyword_prefix=*/"",
           /*keyword_suffix=*/"_",
+          /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
           /*filenames=*/Case::kKeep,
           /*directories=*/Case::kKeep,
           /*output_path=*/"",

src/idl_gen_java.cpp

@@ -46,6 +46,7 @@ static Namer::Config JavaDefaultConfig() {
       /*object_suffix=*/"T",
       /*keyword_prefix=*/"",
       /*keyword_suffix=*/"_",
+      /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
       /*filenames=*/Case::kKeep,
       /*directories=*/Case::kKeep,
       /*output_path=*/"",

src/idl_gen_kotlin.cpp

@@ -64,6 +64,7 @@ static Namer::Config KotlinDefaultConfig() {
           /*object_suffix=*/"T",
           /*keyword_prefix=*/"",
           /*keyword_suffix=*/"_",
+          /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
           /*filenames=*/Case::kKeep,
           /*directories=*/Case::kKeep,
           /*output_path=*/"",

src/idl_gen_kotlin_kmp.cpp

@@ -62,6 +62,7 @@ static Namer::Config KotlinDefaultConfig() {
           /*object_suffix=*/"T",
           /*keyword_prefix=*/"",
           /*keyword_suffix=*/"E",
+          /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
           /*filenames=*/Case::kUpperCamel,
           /*directories=*/Case::kLowerCamel,
           /*output_path=*/"",

src/idl_gen_python.cpp

@@ -593,6 +593,18 @@ class PythonStubGenerator {
                     "bytes) -> uoffset: ...\n";
           }
         }
+
+        stub << "def ";
+        if (!parser_.opts.python_no_type_prefix_suffix) stub << type;
+        stub << "Create" << namer_.Method(*field)
+             << "Vector(builder: flatbuffers.Builder, data: typing.Iterable["
+                "typing.Any]) -> uoffset: ...\n";
+        if (!parser_.opts.one_file &&
+            !parser_.opts.python_no_type_prefix_suffix) {
+          stub << "def Create" << namer_.Method(*field)
+               << "Vector(builder: flatbuffers.Builder, data: "
+                  "typing.Iterable[typing.Any]) -> uoffset: ...\n";
+        }
       }
     }
 
@@ -1201,12 +1213,15 @@ class PythonGenerator : public BaseGenerator {
       return;
     }  // There is no nested flatbuffer.
 
-    const std::string unqualified_name = nested->constant;
+    std::string unqualified_name = nested->constant;
     std::string qualified_name = NestedFlatbufferType(unqualified_name);
     if (qualified_name.empty()) {
       qualified_name = nested->constant;
     }
 
+    // name may be partially qualified -- need to get the true unqualified name
+    unqualified_name = namer_.Denamespace(qualified_name);
+
     const ImportMapEntry import_entry = {qualified_name, unqualified_name};
 
     auto& code = *code_ptr;
@@ -1464,6 +1479,59 @@ class PythonGenerator : public BaseGenerator {
     }
   }
 
+  void BuildVectorCreationHelper(const StructDef& struct_def,
+                                 const FieldDef& field, std::string* code_ptr,
+                                 ImportMap& imports) const {
+    auto& code = *code_ptr;
+    const auto vector_type = field.value.type.VectorType();
+    const bool is_struct_vector = IsStruct(vector_type);
+    const bool is_scalar_vector =
+        IsScalar(vector_type.base_type) || vector_type.enum_def != nullptr;
+    const std::string struct_type = namer_.Type(struct_def);
+    const std::string field_method = namer_.Method(field);
+    const std::string helper_name =
+        parser_.opts.python_no_type_prefix_suffix
+            ? "Create" + field_method + "Vector"
+            : struct_type + "Create" + field_method + "Vector";
+
+    if (parser_.opts.python_typing) {
+      imports.insert(ImportMapEntry{"typing", "Iterable"});
+      code += "def " + helper_name +
+              "(builder: flatbuffers.Builder, data: Iterable[Any]) -> int:\n";
+    } else {
+      code += "def " + helper_name + "(builder, data):\n";
+    }
+
+    if (is_scalar_vector || is_struct_vector) {
+      auto alignment = InlineAlignment(vector_type);
+      auto elem_size = InlineSize(vector_type);
+      code += Indent + "data = list(data)\n";
+      code += Indent + "builder.StartVector(" + NumToString(elem_size) +
+              ", len(data), " + NumToString(alignment) + ")\n";
+      code += Indent + "for item in reversed(data):\n";
+      if (is_struct_vector) {
+        code += Indent + Indent + "item.Pack(builder)\n";
+      } else {
+        code += Indent + Indent + "builder.Prepend" +
+                namer_.Method(GenTypeBasic(vector_type)) + "(item)\n";
+      }
+      code += Indent + "return builder.EndVector()\n\n";
+    } else {
+      code += Indent + "return builder.CreateVectorOfTables(data)\n\n";
+    }
+
+    if (!parser_.opts.one_file && !parser_.opts.python_no_type_prefix_suffix) {
+      if (parser_.opts.python_typing) {
+        code += "def Create" + field_method +
+                "Vector(builder: flatbuffers.Builder, data: Iterable[Any]) "
+                "-> int:\n";
+      } else {
+        code += "def Create" + field_method + "Vector(builder, data):\n";
+      }
+      code += Indent + "return " + helper_name + "(builder, data)\n\n";
+    }
+  }
+
   // Set the value of one of the members of a table's vector and fills in the
   // elements from a bytearray. This is for simplifying the use of nested
   // flatbuffers.
@@ -1614,8 +1682,8 @@ class PythonGenerator : public BaseGenerator {
   }
 
   // Generate table constructors, conditioned on its members' types.
-  void GenTableBuilders(const StructDef& struct_def,
+  void GenTableBuilders(const StructDef& struct_def, std::string* code_ptr,
-                        std::string* code_ptr) const {
+                        ImportMap& imports) const {
     GetStartOfTable(struct_def, code_ptr);
 
     for (auto it = struct_def.fields.vec.begin();
@@ -1627,6 +1695,7 @@ class PythonGenerator : public BaseGenerator {
       BuildFieldOfTable(struct_def, field, offset, code_ptr);
       if (IsVector(field.value.type)) {
         BuildVectorOfTable(struct_def, field, code_ptr);
+        BuildVectorCreationHelper(struct_def, field, code_ptr, imports);
         BuildVectorOfTableFromBytes(struct_def, field, code_ptr);
       }
     }
@@ -1693,7 +1762,7 @@ class PythonGenerator : public BaseGenerator {
       GenStructBuilder(struct_def, code_ptr);
     } else {
       // Creates a set of functions that allow table construction.
-      GenTableBuilders(struct_def, code_ptr);
+      GenTableBuilders(struct_def, code_ptr, imports);
     }
   }
 
@@ -2026,12 +2095,12 @@ class PythonGenerator : public BaseGenerator {
     const auto field_method = namer_.Method(field);
     const auto struct_var = namer_.Variable(struct_def);
     const EnumDef& enum_def = *field.value.type.enum_def;
-    auto union_type = namer_.Type(enum_def);
+    auto union_fn = namer_.Function(enum_def);
 
     if (parser_.opts.include_dependence_headers) {
-      union_type = namer_.NamespacedType(enum_def) + "." + union_type;
+      union_fn = namer_.NamespacedType(enum_def) + "." + union_fn;
     }
-    code += GenIndents(2) + "self." + field_field + " = " + union_type +
+    code += GenIndents(2) + "self." + field_field + " = " + union_fn +
             "Creator(" + "self." + field_field + "Type, " + struct_var + "." +
             field_method + "())";
   }

src/idl_gen_rust.cpp

@@ -49,6 +49,7 @@ static Namer::Config RustDefaultConfig() {
           /*object_suffix=*/"T",
           /*keyword_prefix=*/"",
           /*keyword_suffix=*/"_",
+          /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
           /*filenames=*/Case::kSnake,
           /*directories=*/Case::kSnake,
           /*output_path=*/"",
@@ -423,14 +424,12 @@ class RustGenerator : public BaseGenerator {
     code_.Clear();
     code_ += "// " + std::string(FlatBuffersGeneratedWarning());
     code_ += "// @generated";
-    code_ += "extern crate alloc;";
 
     assert(!cur_name_space_);
 
     // Generate imports for the global scope in case no namespace is used
     // in the schema file.
-    GenNamespaceImports(0);
+    GenNamespaceImports();
-    code_ += "";
 
     // Generate all code in their namespaces, once, because Rust does not
     // permit re-opening modules.
@@ -708,6 +707,8 @@ class RustGenerator : public BaseGenerator {
   // an enum match function,
   // and an enum array of values
   void GenEnum(const EnumDef& enum_def) {
+    code_ += "";
+
     const bool is_private = parser_.opts.no_leak_private_annotations &&
                             (enum_def.attributes.Lookup("private") != nullptr);
     code_.SetValue("ACCESS_TYPE", is_private ? "pub(crate)" : "pub");
@@ -739,6 +740,8 @@ class RustGenerator : public BaseGenerator {
       code_ += "        }";
       code_ += "    }";
       code_ += "}";
+      code_ += "";
+
       code_ += "pub use self::bitflags_{{ENUM_NAMESPACE}}::{{ENUM_TY}};";
       code_ += "";
 
@@ -753,10 +756,14 @@ class RustGenerator : public BaseGenerator {
       code_ +=
           "pub const ENUM_MIN_{{ENUM_CONSTANT}}: {{BASE_TYPE}}"
           " = {{ENUM_MIN_BASE_VALUE}};";
+      code_ += "";
+
       code_ += deprecation_warning;
       code_ +=
           "pub const ENUM_MAX_{{ENUM_CONSTANT}}: {{BASE_TYPE}}"
           " = {{ENUM_MAX_BASE_VALUE}};";
+      code_ += "";
+
       auto num_fields = NumToString(enum_def.size());
       code_ += deprecation_warning;
       code_ += "#[allow(non_camel_case_types)]";
@@ -777,6 +784,8 @@ class RustGenerator : public BaseGenerator {
           "Default)]";
       code_ += "#[repr(transparent)]";
       code_ += "{{ACCESS_TYPE}} struct {{ENUM_TY}}(pub {{BASE_TYPE}});";
+      code_ += "";
+
       code_ += "#[allow(non_upper_case_globals)]";
       code_ += "impl {{ENUM_TY}} {";
       ForAllEnumValues1(enum_def, [&](const EnumVal& ev) {
@@ -785,11 +794,15 @@ class RustGenerator : public BaseGenerator {
       });
       code_ += "";
       // Generate Associated constants
-      code_ += "  pub const ENUM_MIN: {{BASE_TYPE}} = {{ENUM_MIN_BASE_VALUE}};";
+      code_ +=
-      code_ += "  pub const ENUM_MAX: {{BASE_TYPE}} = {{ENUM_MAX_BASE_VALUE}};";
+          "    pub const ENUM_MIN: {{BASE_TYPE}} = {{ENUM_MIN_BASE_VALUE}};";
+      code_ +=
+          "    pub const ENUM_MAX: {{BASE_TYPE}} = {{ENUM_MAX_BASE_VALUE}};";
       code_ += "    pub const ENUM_VALUES: &'static [Self] = &[";
       ForAllEnumValues(enum_def, [&]() { code_ += "    Self::{{VARIANT}},"; });
       code_ += "    ];";
+      code_ += "";
+
       code_ += "    /// Returns the variant's name or \"\" if unknown.";
       code_ += "    pub fn variant_name(self) -> Option<&'static str> {";
       code_ += "        match self {";
@@ -800,6 +813,7 @@ class RustGenerator : public BaseGenerator {
       code_ += "        }";
       code_ += "    }";
       code_ += "}";
+      code_ += "";
 
       // Generate Debug. Unknown variants are printed like "<UNKNOWN 42>".
       code_ += "impl ::core::fmt::Debug for {{ENUM_TY}} {";
@@ -809,10 +823,12 @@ class RustGenerator : public BaseGenerator {
       code_ += "        if let Some(name) = self.variant_name() {";
       code_ += "            f.write_str(name)";
       code_ += "        } else {";
-      code_ += "      f.write_fmt(format_args!(\"<UNKNOWN {:?}>\", self.0))";
+      code_ +=
+          "            f.write_fmt(format_args!(\"<UNKNOWN {:?}>\", self.0))";
       code_ += "        }";
       code_ += "    }";
       code_ += "}";
+      code_ += "";
 
       code_.SetValue("INTO_BASE", "self.0");
     }
@@ -821,7 +837,8 @@ class RustGenerator : public BaseGenerator {
     if (parser_.opts.rust_serialize) {
       code_ += "impl Serialize for {{ENUM_TY}} {";
       code_ +=
-          "  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>";
+          "    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, "
+          "S::Error>";
       code_ += "    where";
       code_ += "        S: Serializer,";
       code_ += "    {";
@@ -846,7 +863,9 @@ class RustGenerator : public BaseGenerator {
         code_ += "    {";
         code_ += "        let s = String::deserialize(deserializer)?;";
         code_ += "        for item in {{ENUM_TY}}::ENUM_VALUES {";
-        code_ += "            if let Some(item_name) = item.variant_name() {";
+        code_ +=
+            "            if let Some(item_name) = "
+            "item.variant_name() {";
         code_ += "                if item_name == s {";
         code_ += "                    return Ok(item.clone());";
         code_ += "                }";
@@ -864,6 +883,7 @@ class RustGenerator : public BaseGenerator {
     // Generate Follow and Push so we can serialize and stuff.
     code_ += "impl<'a> ::flatbuffers::Follow<'a> for {{ENUM_TY}} {";
     code_ += "    type Inner = Self;";
+    code_ += "";
     code_ += "    #[inline]";
     code_ += "    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {";
     code_ +=
@@ -879,6 +899,7 @@ class RustGenerator : public BaseGenerator {
     code_ += "";
     code_ += "impl ::flatbuffers::Push for {{ENUM_TY}} {";
     code_ += "    type Output = {{ENUM_TY}};";
+    code_ += "";
     code_ += "    #[inline]";
     code_ += "    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {";
     code_ +=
@@ -889,10 +910,12 @@ class RustGenerator : public BaseGenerator {
     code_ += "";
     code_ += "impl ::flatbuffers::EndianScalar for {{ENUM_TY}} {";
     code_ += "    type Scalar = {{BASE_TYPE}};";
+    code_ += "";
     code_ += "    #[inline]";
     code_ += "    fn to_little_endian(self) -> {{BASE_TYPE}} {";
     code_ += "        {{INTO_BASE}}.to_le()";
     code_ += "    }";
+    code_ += "";
     code_ += "    #[inline]";
     code_ += "    #[allow(clippy::wrong_self_convention)]";
     code_ += "    fn from_little_endian(v: {{BASE_TYPE}}) -> Self {";
@@ -922,8 +945,8 @@ class RustGenerator : public BaseGenerator {
     if (enum_def.is_union) {
       // Generate typesafe offset(s) for unions
       code_.SetValue("UNION_TYPE", namer_.Type(enum_def));
-      code_ += "{{ACCESS_TYPE}} struct {{UNION_TYPE}}UnionTableOffset {}";
       code_ += "";
+      code_ += "{{ACCESS_TYPE}} struct {{UNION_TYPE}}UnionTableOffset {}";
       if (parser_.opts.generate_object_based_api) {
         GenUnionObject(enum_def);
       }
@@ -955,6 +978,7 @@ class RustGenerator : public BaseGenerator {
     code_.SetValue("ENUM_OTY", namer_.ObjectType(enum_def));
 
     // Generate native union.
+    code_ += "";
     code_ += "#[allow(clippy::upper_case_acronyms)]";  // NONE's spelling is
                                                        // intended.
     code_ += "#[non_exhaustive]";
@@ -966,12 +990,15 @@ class RustGenerator : public BaseGenerator {
           "{{NATIVE_VARIANT}}(alloc::boxed::Box<{{U_ELEMENT_TABLE_TYPE}}>),";
     });
     code_ += "}";
+    code_ += "";
+
     // Generate Default (NONE).
     code_ += "impl Default for {{ENUM_OTY}} {";
     code_ += "    fn default() -> Self {";
     code_ += "        Self::NONE";
     code_ += "    }";
     code_ += "}";
+    code_ += "";
 
     // Generate native union methods.
     code_ += "impl {{ENUM_OTY}} {";
@@ -988,9 +1015,12 @@ class RustGenerator : public BaseGenerator {
     });
     code_ += "        }";
     code_ += "    }";
+    code_ += "";
+
     // Pack flatbuffers union value
     code_ +=
-        "  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: &mut "
+        "    pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(&self, fbb: "
+        "&mut "
         "::flatbuffers::FlatBufferBuilder<'b, A>)"
         " -> Option<::flatbuffers::WIPOffset<::flatbuffers::UnionWIPOffset>>"
         " {";
@@ -1006,6 +1036,7 @@ class RustGenerator : public BaseGenerator {
     // Generate some accessors;
     ForAllUnionObjectVariantsBesidesNone(enum_def, [&] {
       // Move accessor.
+      code_ += "";
       code_ +=
           "/// If the union variant matches, return the owned "
           "{{U_ELEMENT_TABLE_TYPE}}, setting the union to NONE.";
@@ -1023,7 +1054,9 @@ class RustGenerator : public BaseGenerator {
       code_ += "        None";
       code_ += "    }";
       code_ += "}";
+
       // Immutable reference accessor.
+      code_ += "";
       code_ +=
           "/// If the union variant matches, return a reference to the "
           "{{U_ELEMENT_TABLE_TYPE}}.";
@@ -1034,7 +1067,9 @@ class RustGenerator : public BaseGenerator {
           "    if let Self::{{NATIVE_VARIANT}}(v) = self "
           "{ Some(v.as_ref()) } else { None }";
       code_ += "}";
+
       // Mutable reference accessor.
+      code_ += "";
       code_ +=
           "/// If the union variant matches, return a mutable reference"
           " to the {{U_ELEMENT_TABLE_TYPE}}.";
@@ -1046,7 +1081,9 @@ class RustGenerator : public BaseGenerator {
           "{ Some(v.as_mut()) } else { None }";
       code_ += "}";
     });
+
     code_ += "}";  // End union methods impl.
+    code_ += "";
   }
 
   enum DefaultContext { kBuilder, kAccessor, kObject };
@@ -1101,9 +1138,14 @@ class RustGenerator : public BaseGenerator {
         // need one for Rust's Default trait so we use empty string. The usual
         // value of field.value.constant is `0`, which is non-sensical except
         // maybe to c++ (nullptr == 0).
-        // TODO: Escape strings?
+        std::string defval;
-        const std::string defval =
+        if (field.IsRequired()) {
-            field.IsRequired() ? "\"\"" : "\"" + field.value.constant + "\"";
+          defval = "\"\"";
+        } else {
+          flatbuffers::EscapeString(field.value.constant.c_str(),
+                                    field.value.constant.length(), &defval,
+                                    true, false);
+        }
         if (context == kObject) {
           return "alloc::string::ToString::to_string(" + defval + ")";
         }
@@ -1673,6 +1715,8 @@ class RustGenerator : public BaseGenerator {
   // Generate an accessor struct, builder struct, and create function for a
   // table.
   void GenTable(const StructDef& struct_def) {
+    code_ += "";
+
     const bool is_private =
         parser_.opts.no_leak_private_annotations &&
         (struct_def.attributes.Lookup("private") != nullptr);
@@ -1683,17 +1727,18 @@ class RustGenerator : public BaseGenerator {
     // Generate an offset type, the base type, the Follow impl, and the
     // init_from_table impl.
     code_ += "{{ACCESS_TYPE}} enum {{STRUCT_TY}}Offset {}";
-    code_ += "#[derive(Copy, Clone, PartialEq)]";
     code_ += "";
 
     GenComment(struct_def.doc_comment);
 
+    code_ += "#[derive(Copy, Clone, PartialEq)]";
     code_ += "{{ACCESS_TYPE}} struct {{STRUCT_TY}}<'a> {";
     code_ += "    pub _tab: ::flatbuffers::Table<'a>,";
     code_ += "}";
     code_ += "";
     code_ += "impl<'a> ::flatbuffers::Follow<'a> for {{STRUCT_TY}}<'a> {";
     code_ += "    type Inner = {{STRUCT_TY}}<'a>;";
+    code_ += "";
     code_ += "    #[inline]";
     code_ += "    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {";
     code_ +=
@@ -1710,7 +1755,8 @@ class RustGenerator : public BaseGenerator {
           "pub const {{OFFSET_NAME}}: ::flatbuffers::VOffsetT = "
           "{{OFFSET_VALUE}};";
     });
-    code_ += "";
+
+    if (struct_def.fields.vec.size() > 0) { code_ += ""; }
 
     if (parser_.opts.generate_name_strings) {
       GenFullyQualifiedNameGetter(struct_def, struct_def.name);
@@ -1722,6 +1768,7 @@ class RustGenerator : public BaseGenerator {
         "Self {";
     code_ += "        {{STRUCT_TY}} { _tab: table }";
     code_ += "    }";
+    code_ += "";
 
     // Generate a convenient create* function that uses the above builder
     // to create a table in one function call.
@@ -1733,7 +1780,8 @@ class RustGenerator : public BaseGenerator {
         "    pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: "
         "::flatbuffers::Allocator + 'bldr>(";
     code_ +=
-        "    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,";
+        "        _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, "
+        "A>,";
     code_ += "        {{MAYBE_US}}args: &'args {{STRUCT_TY}}Args{{MAYBE_LT}}";
     code_ += "    ) -> ::flatbuffers::WIPOffset<{{STRUCT_TY}}<'bldr>> {";
 
@@ -1759,6 +1807,7 @@ class RustGenerator : public BaseGenerator {
     code_ += "        builder.finish()";
     code_ += "    }";
     code_ += "";
+
     // Generate Object API Packer function.
     if (parser_.opts.generate_object_based_api) {
       // TODO(cneo): Replace more for loops with ForAllX stuff.
@@ -1858,6 +1907,7 @@ class RustGenerator : public BaseGenerator {
           code_ += "    };";
         }
       });
+
       code_ += "        {{STRUCT_OTY}} {";
       ForAllObjectTableFields(struct_def, [&](const FieldDef& field) {
         if (field.value.type.base_type == BASE_TYPE_UTYPE) return;
@@ -1867,8 +1917,6 @@ class RustGenerator : public BaseGenerator {
       code_ += "    }";
     }
 
-    if (struct_def.fields.vec.size() > 0) code_ += "";
-
     // Generate the accessors. Each has one of two forms:
     //
     // If a value can be None:
@@ -1881,6 +1929,7 @@ class RustGenerator : public BaseGenerator {
     //     self._tab.get::<internal_type>(offset, defaultval).unwrap()
     //   }
     ForAllTableFields(struct_def, [&](const FieldDef& field) {
+      code_ += "";
       code_.SetValue("RETURN_TYPE",
                      GenTableAccessorFuncReturnType(field, "'a"));
 
@@ -1911,6 +1960,7 @@ class RustGenerator : public BaseGenerator {
         FLATBUFFERS_ASSERT(nested_root);  // Guaranteed to exist by parser.
 
         code_.SetValue("NESTED", WrapInNameSpace(*nested_root));
+        code_ += "";
         code_ += "pub fn {{FIELD}}_nested_flatbuffer(&'a self) -> \\";
         if (field.IsRequired()) {
           code_ += "{{NESTED}}<'a> {";
@@ -1930,7 +1980,8 @@ class RustGenerator : public BaseGenerator {
           code_ += "        // Created from a valid Table for this object";
           code_ += "        // Which contains a valid flatbuffer in this slot";
           code_ +=
-              "    unsafe { <::flatbuffers::ForwardsUOffset<{{NESTED}}<'a>>>"
+              "        unsafe { "
+              "<::flatbuffers::ForwardsUOffset<{{NESTED}}<'a>>>"
               "::follow(data.bytes(), 0) }";
           code_ += "    })";
         }
@@ -1944,6 +1995,7 @@ class RustGenerator : public BaseGenerator {
       ForAllUnionVariantsBesidesNone(
           *field.value.type.enum_def, [&](const EnumVal& unused) {
             (void)unused;
+            code_ += "";
             code_ += "#[inline]";
             code_ += "#[allow(non_snake_case)]";
             code_ +=
@@ -1976,10 +2028,13 @@ class RustGenerator : public BaseGenerator {
             } else {
               code_ += "        self.{{FIELD}}().map(|t| {";
               code_ += "            // Safety:";
-              code_ += "     // Created from a valid Table for this object";
-              code_ += "     // Which contains a valid union in this slot";
               code_ +=
-                  "     unsafe { {{U_ELEMENT_TABLE_TYPE}}::init_from_table(t) "
+                  "            // Created from a valid Table for this object";
+              code_ +=
+                  "            // Which contains a valid union in this slot";
+              code_ +=
+                  "            unsafe { "
+                  "{{U_ELEMENT_TABLE_TYPE}}::init_from_table(t) "
                   "}";
               code_ += "        })";
             }
@@ -1987,7 +2042,6 @@ class RustGenerator : public BaseGenerator {
             code_ += "        None";
             code_ += "    }";
             code_ += "}";
-            code_ += "";
           });
     });
     code_ += "}";  // End of table impl.
@@ -1999,7 +2053,7 @@ class RustGenerator : public BaseGenerator {
     code_ += "    fn run_verifier(";
     code_ += "        v: &mut ::flatbuffers::Verifier, pos: usize";
     code_ += "    ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {";
-    code_ += "    v.visit_table(pos)?\\";
+    code_ += "        v.visit_table(pos)?";
     // Escape newline and insert it onthe next line so we can end the builder
     // with a nice semicolon.
     ForAllTableFields(struct_def, [&](const FieldDef& field) {
@@ -2010,8 +2064,8 @@ class RustGenerator : public BaseGenerator {
         // All types besides unions.
         code_.SetValue("TY", FollowType(field.value.type, "'_"));
         code_ +=
-            "\n     .visit_field::<{{TY}}>(\"{{FIELD}}\", "
+            "        .visit_field::<{{TY}}>(\"{{FIELD}}\", "
-            "Self::{{OFFSET_NAME}}, {{IS_REQ}})?\\";
+            "Self::{{OFFSET_NAME}}, {{IS_REQ}})?";
         return;
       }
       // Unions.
@@ -2022,7 +2076,7 @@ class RustGenerator : public BaseGenerator {
       code_.SetValue("UNION_TYPE_METHOD",
                      namer_.LegacyRustUnionTypeMethod(field));
       code_ +=
-          "\n     .visit_union::<{{UNION_TYPE}}, _>("
+          "        .visit_union::<{{UNION_TYPE}}, _>("
           "\"{{UNION_TYPE_METHOD}}\", Self::{{UNION_TYPE_OFFSET_NAME}}, "
           "\"{{FIELD}}\", Self::{{OFFSET_NAME}}, {{IS_REQ}}, "
           "|key, v, pos| {";
@@ -2030,18 +2084,20 @@ class RustGenerator : public BaseGenerator {
       ForAllUnionVariantsBesidesNone(union_def, [&](const EnumVal& unused) {
         (void)unused;
         code_ +=
-            "        {{U_ELEMENT_ENUM_TYPE}} => v.verify_union_variant::"
+            "                {{U_ELEMENT_ENUM_TYPE}} => "
+            "v.verify_union_variant::"
             "<::flatbuffers::ForwardsUOffset<{{U_ELEMENT_TABLE_TYPE}}>>("
             "\"{{U_ELEMENT_ENUM_TYPE}}\", pos),";
       });
       code_ += "                _ => Ok(()),";
       code_ += "            }";
-      code_ += "   })?\\";
+      code_ += "        })?";
     });
-    code_ += "\n     .finish();";
+    code_ += "            .finish();";
     code_ += "        Ok(())";
     code_ += "    }";
     code_ += "}";
+    code_ += "";
 
     // Generate an args struct:
     code_.SetValue("MAYBE_LT",
@@ -2049,9 +2105,10 @@ class RustGenerator : public BaseGenerator {
     code_ += "{{ACCESS_TYPE}} struct {{STRUCT_TY}}Args{{MAYBE_LT}} {";
     ForAllTableFields(struct_def, [&](const FieldDef& field) {
       code_.SetValue("PARAM_TYPE", TableBuilderArgsDefnType(field, "'a"));
-      code_ += "  pub {{FIELD}}: {{PARAM_TYPE}},";
+      code_ += "pub {{FIELD}}: {{PARAM_TYPE}},";
     });
     code_ += "}";
+    code_ += "";
 
     // Generate an impl of Default for the *Args type:
     code_ += "impl<'a> Default for {{STRUCT_TY}}Args{{MAYBE_LT}} {";
@@ -2073,17 +2130,19 @@ class RustGenerator : public BaseGenerator {
       code_.SetValue("NUM_FIELDS", NumToString(numFields));
       code_ += "impl Serialize for {{STRUCT_TY}}<'_> {";
       code_ +=
-          "  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>";
+          "    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, "
+          "S::Error>";
       code_ += "    where";
       code_ += "        S: Serializer,";
       code_ += "    {";
       if (numFields == 0) {
         code_ +=
-            "    let s = serializer.serialize_struct(\"{{STRUCT_TY}}\", 0)?;";
+            "        let s = serializer.serialize_struct(\"{{STRUCT_TY}}\", "
+            "0)?;";
       } else {
         code_ +=
-            "    let mut s = serializer.serialize_struct(\"{{STRUCT_TY}}\", "
+            "        let mut s = "
-            "{{NUM_FIELDS}})?;";
+            "serializer.serialize_struct(\"{{STRUCT_TY}}\", {{NUM_FIELDS}})?;";
       }
       ForAllTableFields(struct_def, [&](const FieldDef& field) {
         const Type& type = field.value.type;
@@ -2145,6 +2204,7 @@ class RustGenerator : public BaseGenerator {
         "    start_: ::flatbuffers::WIPOffset<"
         "::flatbuffers::TableUnfinishedWIPOffset>,";
     code_ += "}";
+    code_ += "";
 
     // Generate builder functions:
     code_ +=
@@ -2180,6 +2240,7 @@ class RustGenerator : public BaseGenerator {
         code_ += "    {{FUNC_BODY}}({{FIELD_OFFSET}}, {{FIELD}});";
       }
       code_ += "}";
+      code_ += "";
     });
 
     // Struct initializer (all fields required);
@@ -2195,6 +2256,7 @@ class RustGenerator : public BaseGenerator {
     code_ += "            start_: start,";
     code_ += "        }";
     code_ += "    }";
+    code_ += "";
 
     // finish() function.
     code_ += "    #[inline]";
@@ -2258,6 +2320,8 @@ class RustGenerator : public BaseGenerator {
   }
 
   void GenTableObject(const StructDef& table) {
+    code_ += "";
+
     code_.SetValue("STRUCT_OTY", namer_.ObjectType(table));
     code_.SetValue("STRUCT_TY", namer_.Type(table));
 
@@ -2272,6 +2336,7 @@ class RustGenerator : public BaseGenerator {
       code_ += "pub {{FIELD}}: {{FIELD_OTY}},";
     });
     code_ += "}";
+    code_ += "";
 
     code_ += "impl Default for {{STRUCT_OTY}} {";
     code_ += "    fn default() -> Self {";
@@ -2284,6 +2349,7 @@ class RustGenerator : public BaseGenerator {
     code_ += "        }";
     code_ += "    }";
     code_ += "}";
+    code_ += "";
 
     // TODO(cneo): Generate defaults for Native tables. However, since structs
     // may be required, they, and therefore enums need defaults.
@@ -2430,6 +2496,8 @@ class RustGenerator : public BaseGenerator {
     code_.SetValue("KEY_TYPE", GenTableAccessorFuncReturnType(field, ""));
     code_.SetValue("REF", IsString(field.value.type) ? "" : "&");
 
+    code_ += "";
+
     code_ += "#[inline]";
     code_ +=
         "pub fn key_compare_less_than(&self, o: &{{STRUCT_TY}}) -> "
@@ -2437,6 +2505,7 @@ class RustGenerator : public BaseGenerator {
     code_ += "    self.{{FIELD}}() < o.{{FIELD}}()";
     code_ += "}";
     code_ += "";
+
     code_ += "#[inline]";
     code_ +=
         "pub fn key_compare_with_value(&self, val: {{KEY_TYPE}}) -> "
@@ -2449,60 +2518,69 @@ class RustGenerator : public BaseGenerator {
   // Generate functions for accessing the root table object. This function
   // must only be called if the root table is defined.
   void GenRootTableFuncs(const StructDef& struct_def) {
+    code_ += "";
+
     FLATBUFFERS_ASSERT(parser_.root_struct_def_ && "root table not defined");
     code_.SetValue("STRUCT_TY", namer_.Type(struct_def));
     code_.SetValue("STRUCT_FN", namer_.Function(struct_def));
     code_.SetValue("STRUCT_CONST", namer_.Constant(struct_def.name));
 
     // Default verifier root fns.
-    code_ += "#[inline]";
     code_ += "/// Verifies that a buffer of bytes contains a `{{STRUCT_TY}}`";
     code_ += "/// and returns it.";
     code_ += "/// Note that verification is still experimental and may not";
     code_ += "/// catch every error, or be maximally performant. For the";
     code_ += "/// previous, unchecked, behavior use";
     code_ += "/// `root_as_{{STRUCT_FN}}_unchecked`.";
+    code_ += "#[inline]";
     code_ +=
         "pub fn root_as_{{STRUCT_FN}}(buf: &[u8]) "
         "-> Result<{{STRUCT_TY}}<'_>, ::flatbuffers::InvalidFlatbuffer> {";
     code_ += "    ::flatbuffers::root::<{{STRUCT_TY}}>(buf)";
     code_ += "}";
-    code_ += "#[inline]";
+    code_ += "";
+
     code_ += "/// Verifies that a buffer of bytes contains a size prefixed";
     code_ += "/// `{{STRUCT_TY}}` and returns it.";
     code_ += "/// Note that verification is still experimental and may not";
     code_ += "/// catch every error, or be maximally performant. For the";
     code_ += "/// previous, unchecked, behavior use";
     code_ += "/// `size_prefixed_root_as_{{STRUCT_FN}}_unchecked`.";
+    code_ += "#[inline]";
     code_ +=
         "pub fn size_prefixed_root_as_{{STRUCT_FN}}"
         "(buf: &[u8]) -> Result<{{STRUCT_TY}}<'_>, "
         "::flatbuffers::InvalidFlatbuffer> {";
     code_ += "    ::flatbuffers::size_prefixed_root::<{{STRUCT_TY}}>(buf)";
     code_ += "}";
+    code_ += "";
+
     // Verifier with options root fns.
-    code_ += "#[inline]";
     code_ += "/// Verifies, with the given options, that a buffer of bytes";
     code_ += "/// contains a `{{STRUCT_TY}}` and returns it.";
     code_ += "/// Note that verification is still experimental and may not";
     code_ += "/// catch every error, or be maximally performant. For the";
     code_ += "/// previous, unchecked, behavior use";
     code_ += "/// `root_as_{{STRUCT_FN}}_unchecked`.";
+    code_ += "#[inline]";
     code_ += "pub fn root_as_{{STRUCT_FN}}_with_opts<'b, 'o>(";
     code_ += "    opts: &'o ::flatbuffers::VerifierOptions,";
     code_ += "    buf: &'b [u8],";
     code_ +=
         ") -> Result<{{STRUCT_TY}}<'b>, ::flatbuffers::InvalidFlatbuffer>"
         " {";
-    code_ += "  ::flatbuffers::root_with_opts::<{{STRUCT_TY}}<'b>>(opts, buf)";
+    code_ +=
+        "    ::flatbuffers::root_with_opts::<{{STRUCT_TY}}<'b>>(opts, buf)";
     code_ += "}";
-    code_ += "#[inline]";
+    code_ += "";
+
     code_ += "/// Verifies, with the given verifier options, that a buffer of";
     code_ += "/// bytes contains a size prefixed `{{STRUCT_TY}}` and returns";
     code_ += "/// it. Note that verification is still experimental and may not";
     code_ += "/// catch every error, or be maximally performant. For the";
     code_ += "/// previous, unchecked, behavior use";
     code_ += "/// `root_as_{{STRUCT_FN}}_unchecked`.";
+    code_ += "#[inline]";
     code_ +=
         "pub fn size_prefixed_root_as_{{STRUCT_FN}}_with_opts"
         "<'b, 'o>(";
@@ -2515,8 +2593,9 @@ class RustGenerator : public BaseGenerator {
         "    ::flatbuffers::size_prefixed_root_with_opts::<{{STRUCT_TY}}"
         "<'b>>(opts, buf)";
     code_ += "}";
+    code_ += "";
+
     // Unchecked root fns.
-    code_ += "#[inline]";
     code_ +=
         "/// Assumes, without verification, that a buffer of bytes "
         "contains a {{STRUCT_TY}} and returns it.";
@@ -2524,12 +2603,15 @@ class RustGenerator : public BaseGenerator {
     code_ +=
         "/// Callers must trust the given bytes do indeed contain a valid"
         " `{{STRUCT_TY}}`.";
+    code_ += "#[inline]";
     code_ +=
         "pub unsafe fn root_as_{{STRUCT_FN}}_unchecked"
         "(buf: &[u8]) -> {{STRUCT_TY}}<'_> {";
-    code_ += "  unsafe { ::flatbuffers::root_unchecked::<{{STRUCT_TY}}>(buf) }";
+    code_ +=
+        "    unsafe { ::flatbuffers::root_unchecked::<{{STRUCT_TY}}>(buf) }";
     code_ += "}";
-    code_ += "#[inline]";
+    code_ += "";
+
     code_ +=
         "/// Assumes, without verification, that a buffer of bytes "
         "contains a size prefixed {{STRUCT_TY}} and returns it.";
@@ -2537,6 +2619,7 @@ class RustGenerator : public BaseGenerator {
     code_ +=
         "/// Callers must trust the given bytes do indeed contain a valid"
         " size prefixed `{{STRUCT_TY}}`.";
+    code_ += "#[inline]";
     code_ +=
         "pub unsafe fn size_prefixed_root_as_{{STRUCT_FN}}"
         "_unchecked(buf: &[u8]) -> {{STRUCT_TY}}<'_> {";
@@ -2545,6 +2628,7 @@ class RustGenerator : public BaseGenerator {
         "::flatbuffers::size_prefixed_root_unchecked::<{{STRUCT_TY}}>"
         "(buf) }";
     code_ += "}";
+    code_ += "";
 
     if (parser_.file_identifier_.length()) {
       // Declare the identifier
@@ -2583,7 +2667,8 @@ class RustGenerator : public BaseGenerator {
         "pub fn finish_{{STRUCT_FN}}_buffer<'a, 'b, A: "
         "::flatbuffers::Allocator + 'a>(";
     code_ += "    fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,";
-    code_ += "    root: ::flatbuffers::WIPOffset<{{STRUCT_TY}}<'a>>) {";
+    code_ += "    root: ::flatbuffers::WIPOffset<{{STRUCT_TY}}<'a>>";
+    code_ += ") {";
     if (parser_.file_identifier_.length()) {
       code_ += "    fbb.finish(root, Some({{STRUCT_CONST}}_IDENTIFIER));";
     } else {
@@ -2594,9 +2679,10 @@ class RustGenerator : public BaseGenerator {
     code_ += "#[inline]";
     code_ +=
         "pub fn finish_size_prefixed_{{STRUCT_FN}}_buffer"
-        "<'a, 'b, A: ::flatbuffers::Allocator + 'a>("
+        "<'a, 'b, A: ::flatbuffers::Allocator + 'a>(";
-        "fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, "
+    code_ += "    fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,";
-        "root: ::flatbuffers::WIPOffset<{{STRUCT_TY}}<'a>>) {";
+    code_ += "    root: ::flatbuffers::WIPOffset<{{STRUCT_TY}}<'a>>";
+    code_ += ") {";
     if (parser_.file_identifier_.length()) {
       code_ +=
           "    fbb.finish_size_prefixed(root, "
@@ -2652,6 +2738,8 @@ class RustGenerator : public BaseGenerator {
   }
   // Generate an accessor struct with constructor for a flatbuffers struct.
   void GenStruct(const StructDef& struct_def) {
+    code_ += "";
+
     const bool is_private =
         parser_.opts.no_leak_private_annotations &&
         (struct_def.attributes.Lookup("private") != nullptr);
@@ -2674,11 +2762,14 @@ class RustGenerator : public BaseGenerator {
     code_ += "#[repr(transparent)]";
     code_ += "#[derive(Clone, Copy, PartialEq)]";
     code_ += "{{ACCESS_TYPE}} struct {{STRUCT_TY}}(pub [u8; {{STRUCT_SIZE}}]);";
-    code_ += "impl Default for {{STRUCT_TY}} { ";
+    code_ += "";
-    code_ += "  fn default() -> Self { ";
+
+    code_ += "impl Default for {{STRUCT_TY}} {";
+    code_ += "    fn default() -> Self {";
     code_ += "        Self([0; {{STRUCT_SIZE}}])";
     code_ += "    }";
     code_ += "}";
+    code_ += "";
 
     // Debug for structs.
     code_ += "impl ::core::fmt::Debug for {{STRUCT_TY}} {";
@@ -2699,15 +2790,21 @@ class RustGenerator : public BaseGenerator {
     // Follow for the value type, Follow for the reference type, Push for the
     // value type, and Push for the reference type.
     code_ += "impl ::flatbuffers::SimpleToVerifyInSlice for {{STRUCT_TY}} {}";
+    code_ += "";
+
     code_ += "impl<'a> ::flatbuffers::Follow<'a> for {{STRUCT_TY}} {";
     code_ += "    type Inner = &'a {{STRUCT_TY}};";
+    code_ += "";
     code_ += "    #[inline]";
     code_ += "    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {";
     code_ += "        unsafe { <&'a {{STRUCT_TY}}>::follow(buf, loc) }";
     code_ += "    }";
     code_ += "}";
+    code_ += "";
+
     code_ += "impl<'a> ::flatbuffers::Follow<'a> for &'a {{STRUCT_TY}} {";
     code_ += "    type Inner = &'a {{STRUCT_TY}};";
+    code_ += "";
     code_ += "    #[inline]";
     code_ += "    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {";
     code_ +=
@@ -2715,8 +2812,11 @@ class RustGenerator : public BaseGenerator {
         "loc) }";
     code_ += "    }";
     code_ += "}";
+    code_ += "";
+
     code_ += "impl<'b> ::flatbuffers::Push for {{STRUCT_TY}} {";
     code_ += "    type Output = {{STRUCT_TY}};";
+    code_ += "";
     code_ += "    #[inline]";
     code_ += "    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {";
     code_ +=
@@ -2725,6 +2825,8 @@ class RustGenerator : public BaseGenerator {
         "{{STRUCT_TY}} as *const u8, <Self as ::flatbuffers::Push>::size()) };";
     code_ += "        dst.copy_from_slice(src);";
     code_ += "    }";
+    code_ += "";
+
     code_ += "    #[inline]";
     code_ += "    fn alignment() -> ::flatbuffers::PushAlignment {";
     code_ += "        ::flatbuffers::PushAlignment::new({{ALIGN}})";
@@ -2750,7 +2852,8 @@ class RustGenerator : public BaseGenerator {
       code_.SetValue("NUM_FIELDS", NumToString(numFields));
       code_ += "impl Serialize for {{STRUCT_TY}} {";
       code_ +=
-          "  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>";
+          "    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, "
+          "S::Error>";
       code_ += "    where";
       code_ += "        S: Serializer,";
       code_ += "    {";
@@ -2934,18 +3037,61 @@ class RustGenerator : public BaseGenerator {
     }
 
     code_ += "}";  // End impl Struct methods.
-    code_ += "";
 
     // Generate Struct Object.
     if (parser_.opts.generate_object_based_api) {
       // Struct declaration
-      code_ += "#[derive(Debug, Clone, PartialEq, Default)]";
+      code_ += "";
+      code_ += "#[derive(Debug, Clone, PartialEq)]";
       code_ += "{{ACCESS_TYPE}} struct {{STRUCT_OTY}} {";
       ForAllStructFields(struct_def, [&](const FieldDef& field) {
         (void)field;  // unused.
         code_ += "pub {{FIELD}}: {{FIELD_OTY}},";
       });
       code_ += "}";
+      // Manual impl Default to avoid issues with arrays > 32 elements
+      // where #[derive(Default)] fails on older Rust versions.
+      code_ += "impl Default for {{STRUCT_OTY}} {";
+      code_ += "    fn default() -> Self {";
+      code_ += "        Self {";
+      ForAllStructFields(struct_def, [&](const FieldDef& field) {
+        const auto full_type = GetFullType(field.value.type);
+        switch (full_type) {
+          case ftArrayOfBuiltin: {
+            // Use the correct zero literal for each element type:
+            // bool -> false, float/double -> 0.0, integers -> 0
+            const auto elem_type = field.value.type.VectorType().base_type;
+            std::string zero;
+            if (elem_type == BASE_TYPE_BOOL) {
+              zero = "false";
+            } else if (IsFloat(elem_type)) {
+              zero = "0.0";
+            } else {
+              zero = "0";
+            }
+            code_ += "        {{FIELD}}: [" + zero + "; " +
+                     NumToString(field.value.type.fixed_length) + "],";
+            break;
+          }
+          case ftArrayOfEnum:
+          case ftArrayOfStruct: {
+            code_ +=
+                "        {{FIELD}}: ::flatbuffers::array_init(|_| "
+                "Default::default()),";
+            break;
+          }
+          default: {
+            std::string default_value =
+                GetDefaultValue(field, kObject);
+            code_ += "        {{FIELD}}: " + default_value + ",";
+            break;
+          }
+        }
+      });
+      code_ += "        }";
+      code_ += "    }";
+      code_ += "}";
+      code_ += "";
       // The `pack` method that turns the native struct into its Flatbuffers
       // counterpart.
       code_ += "impl {{STRUCT_OTY}} {";
@@ -2969,16 +3115,13 @@ class RustGenerator : public BaseGenerator {
       code_ += "        )";
       code_ += "    }";
       code_ += "}";
-      code_ += "";
     }
   }
 
-  void GenNamespaceImports(const int white_spaces) {
+  void GenNamespaceImports() {
     // DO not use global attributes (i.e. #![...]) since it interferes
     // with users who include! generated files.
     // See: https://github.com/google/flatbuffers/issues/6261
-    std::string indent = std::string(white_spaces, ' ');
-    code_ += "";
     if (!parser_.opts.generate_all) {
       for (auto it = parser_.included_files_.begin();
            it != parser_.included_files_.end(); ++it) {
@@ -2987,24 +3130,24 @@ class RustGenerator : public BaseGenerator {
         auto basename = flatbuffers::StripPath(noext);
 
         if (parser_.opts.include_prefix.empty()) {
-          code_ += indent + "use crate::" + basename +
+          code_ +=
-                   parser_.opts.filename_suffix + "::*;";
+              "use crate::" + basename + parser_.opts.filename_suffix + "::*;";
         } else {
           auto prefix = parser_.opts.include_prefix;
           prefix.pop_back();
 
-          code_ += indent + "use crate::" + prefix + "::" + basename +
+          code_ += "use crate::" + prefix + "::" + basename +
                    parser_.opts.filename_suffix + "::*;";
         }
       }
     }
+
     if (parser_.opts.rust_serialize) {
-      code_ += indent + "extern crate serde;";
+      code_ += "extern crate serde;";
       code_ +=
-          indent +
           "use self::serde::ser::{Serialize, Serializer, SerializeStruct};";
-      code_ += "";
     }
+    code_ += "extern crate alloc;";
   }
 
   // Set up the correct namespace. This opens a namespace if the current
@@ -3035,22 +3178,18 @@ class RustGenerator : public BaseGenerator {
     // Close cur_name_space in reverse order to reach the common prefix.
     // In the previous example, D then C are closed.
     for (size_t j = old_size; j > common_prefix_size; --j) {
+      code_.DecrementIdentLevel();
       code_ += "} // pub mod " + cur_name_space_->components[j - 1];
     }
-    if (old_size != common_prefix_size) {
-      code_ += "";
-    }
 
     // open namespace parts to reach the ns namespace
     // in the previous example, E, then F, then G are opened
     for (auto j = common_prefix_size; j != new_size; ++j) {
+      code_ += "";
       code_ += "#[allow(unused_imports, dead_code)]";
       code_ += "pub mod " + namer_.Namespace(ns->components[j]) + " {";
-      // Generate local namespace imports.
+      code_.IncrementIdentLevel();
-      GenNamespaceImports(2);
+      GenNamespaceImports();
-    }
-    if (new_size != common_prefix_size) {
-      code_ += "";
     }
 
     cur_name_space_ = ns;

src/idl_gen_swift.cpp

@@ -47,6 +47,7 @@ static Namer::Config SwiftDefaultConfig() {
           /*object_suffix=*/"T",
           /*keyword_prefix=*/"",
           /*keyword_suffix=*/"_",
+          /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
           /*filenames=*/Case::kKeep,
           /*directories=*/Case::kKeep,
           /*output_path=*/"",
@@ -163,7 +164,7 @@ class SwiftGenerator : public BaseGenerator {
   bool generate() {
     code_.Clear();
     code_.SetValue("ACCESS", "_accessor");
-    code_.SetValue("TABLEOFFSET", "VTOFFSET");
+    code_.SetValue("TABLEOFFSET", "VT");
     code_ += "// " + std::string(FlatBuffersGeneratedWarning());
     code_ += "// swiftlint:disable all";
     code_ += "// swiftformat:disable all\n";
@@ -281,9 +282,16 @@ class SwiftGenerator : public BaseGenerator {
             NumToString(field.value.type.VectorType().fixed_length);
         code_.SetValue("FIXEDLENGTH", fixed_length);
 
-        const auto vector_base_type = IsStruct(field.value.type.VectorType())
+        std::string vector_base_type;
-                                          ? (type + "()")
+        if (IsStruct(field.value.type.VectorType())) {
-                                          : SwiftConstant(field);
+          vector_base_type = type + "()";
+        } else if (IsBool(field.value.type.VectorType().base_type)) {
+          vector_base_type = "false";
+        } else if (IsFloat(field.value.type.VectorType().base_type)) {
+          vector_base_type = "0.0";
+        } else {
+          vector_base_type = SwiftConstant(field);
+        }
         code_ += "private var _{{FIELDVAR}}: InlineArray<{{FIXEDLENGTH}}, " +
                  valueType + ">";
 
@@ -517,7 +525,7 @@ class SwiftGenerator : public BaseGenerator {
   void GenTableAccessors(const StructDef& struct_def) {
     // Generate field id constants.
     if (struct_def.fields.vec.size() > 0) {
-      code_ += "private enum {{TABLEOFFSET}}: VOffset {";
+      code_ += "private struct {{TABLEOFFSET}} {";
       Indent();
       for (auto it = struct_def.fields.vec.begin();
            it != struct_def.fields.vec.end(); ++it) {
@@ -527,10 +535,8 @@ class SwiftGenerator : public BaseGenerator {
         }
         code_.SetValue("OFFSET_NAME", namer_.Variable(field));
         code_.SetValue("OFFSET_VALUE", NumToString(field.value.offset));
-        code_ += "case {{OFFSET_NAME}} = {{OFFSET_VALUE}}";
+        code_ += "static let {{OFFSET_NAME}}: VOffset = {{OFFSET_VALUE}}";
       }
-      code_ += "var v: Int32 { Int32(self.rawValue) }";
-      code_ += "var p: VOffset { self.rawValue }";
       Outdent();
       code_ += "}";
       code_ += "";
@@ -619,7 +625,8 @@ class SwiftGenerator : public BaseGenerator {
     if (should_generate_create) {
       code_ += "{{ACCESS_TYPE}} static func create{{SHORT_STRUCTNAME}}(";
       Indent();
-      code_ += "_ fbb: inout FlatBufferBuilder,";
+      code_ += "_ fbb: inout FlatBufferBuilder\\";
+      if (create_func_header.empty() == false) code_ += ",";
       for (auto it = create_func_header.begin(); it < create_func_header.end();
            ++it) {
         code_ += *it + "\\";
@@ -698,7 +705,7 @@ class SwiftGenerator : public BaseGenerator {
       code_ += field.IsOptional() ? (optional_enum + "\\")
                                   : (is_enum + ", def: {{CONSTANT}}\\");
 
-      code_ += ", at: {{TABLEOFFSET}}.{{OFFSET}}.p) }";
+      code_ += ", at: {{TABLEOFFSET}}.{{OFFSET}}) }";
 
       const auto default_value =
           IsEnum(field.value.type)
@@ -718,7 +725,7 @@ class SwiftGenerator : public BaseGenerator {
       code_ +=
           "{{VALUETYPE}}" + builder_string + "fbb.add(element: {{FIELDVAR}},\\";
       code_ += field.IsOptional() ? "\\" : " def: {{CONSTANT}},";
-      code_ += " at: {{TABLEOFFSET}}.{{OFFSET}}.p) }";
+      code_ += " at: {{TABLEOFFSET}}.{{OFFSET}}) }";
       create_func_header.push_back(
           field_var + ": " + nullable_type + " = " +
           (field.IsOptional() ? "nil" : default_value));
@@ -729,7 +736,7 @@ class SwiftGenerator : public BaseGenerator {
       const auto create_struct =
           "guard let {{FIELDVAR}} = {{FIELDVAR}} else { return };"
           " fbb.create(struct: {{FIELDVAR}}, position: "
-          "{{TABLEOFFSET}}.{{OFFSET}}.p) }";
+          "{{TABLEOFFSET}}.{{OFFSET}}) }";
       code_ += type + "?" + builder_string + create_struct;
       /// Optional hard coded since structs are always optional
       create_func_header.push_back(field_var + ": " + type +
@@ -746,8 +753,9 @@ class SwiftGenerator : public BaseGenerator {
                                  (field.IsRequired() ? "" : " = Offset()"));
     const auto reader_type =
         IsStruct(field.value.type) && field.value.type.struct_def->fixed
-            ? "structOffset: {{TABLEOFFSET}}.{{OFFSET}}.p) }"
+            ? "structOffset: {{TABLEOFFSET}}.{{OFFSET}}) }"
-            : "offset: {{FIELDVAR}}, at: {{TABLEOFFSET}}.{{OFFSET}}.p) }";
+            : "offset: {{FIELDVAR}}, at: {{TABLEOFFSET}}.{{OFFSET}}) "
+              "}";
     code_ += "Offset" + builder_string + "fbb.add(" + reader_type;
 
     const auto vectortype = field.value.type.VectorType();
@@ -851,7 +859,10 @@ class SwiftGenerator : public BaseGenerator {
         break;
 
       case BASE_TYPE_STRING: {
-        const auto default_string = "\"" + SwiftConstant(field) + "\"";
+        const auto sc = SwiftConstant(field);
+        std::string default_string;
+        flatbuffers::EscapeString(sc.c_str(), sc.length(), &default_string,
+                                  true, false);
         code_.SetValue("VALUETYPE", GenType(field.value.type));
         code_.SetValue("CONSTANT", field.IsDefault() ? default_string : "nil");
         code_ += GenReaderMainBody(is_required) + GenOffset() +
@@ -859,7 +870,7 @@ class SwiftGenerator : public BaseGenerator {
         code_ += "{{ACCESS_TYPE}} var {{FIELDVAR}}SegmentArray: [UInt8]" +
                  is_required +
                  " { return "
-                 "{{ACCESS}}.getVector(at: {{TABLEOFFSET}}.{{OFFSET}}.v) }";
+                 "{{ACCESS}}.getVector(at: {{TABLEOFFSET}}.{{OFFSET}}) }";
         break;
       }
       case BASE_TYPE_ARRAY:
@@ -893,7 +904,7 @@ class SwiftGenerator : public BaseGenerator {
       code_ +=
           "{{ACCESS_TYPE}} var {{FIELDVAR}}: "
           "FlatbufferVector<{{VALUETYPE}}> "
-          "{ return {{ACCESS}}.vector(at: {{TABLEOFFSET}}.{{OFFSET}}.v, "
+          "{ return {{ACCESS}}.vector(at: {{TABLEOFFSET}}.{{OFFSET}}, "
           "byteSize: {{SIZE}}) }";
     }
 
@@ -910,7 +921,7 @@ class SwiftGenerator : public BaseGenerator {
       code_ +=
           "{{ACCESS_TYPE}} var {{FIELDVAR}}: "
           "FlatbufferVector<{{VALUETYPE}}_Mutable> "
-          "{ return {{ACCESS}}.vector(at: {{TABLEOFFSET}}.{{OFFSET}}.v, "
+          "{ return {{ACCESS}}.vector(at: {{TABLEOFFSET}}.{{OFFSET}}, "
           "byteSize: {{SIZE}}) }";
       GenUnsafeBufferPointer(field);
       return;
@@ -919,7 +930,8 @@ class SwiftGenerator : public BaseGenerator {
     if (vectortype.base_type == BASE_TYPE_UNION) {
       code_ +=
           "{{ACCESS_TYPE}} var {{FIELDVAR}}: UnionFlatbufferVector "
-          "{ return {{ACCESS}}.unionVector(at: {{TABLEOFFSET}}.{{OFFSET}}.v, "
+          "{ return {{ACCESS}}.unionVector(at: "
+          "{{TABLEOFFSET}}.{{OFFSET}}, "
           "byteSize: {{SIZE}}) }";
       code_ +=
           "{{ACCESS_TYPE}} func {{FIELDVAR}}<T: FlatbuffersInitializable>(at "
@@ -953,24 +965,21 @@ class SwiftGenerator : public BaseGenerator {
         "{{ACCESS_TYPE}} func {{functionName}}<T>(_ body: "
         "(UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T? { return "
         "try "
-        "{{ACCESS}}.withUnsafePointerToSlice(at: {{TABLEOFFSET}}.{{OFFSET}}.v, "
+        "{{ACCESS}}.withUnsafePointerToSlice(at: "
+        "{{TABLEOFFSET}}.{{OFFSET}}, "
         "body: body) }";
   }
 
-  void GenerateCodingKeys(const StructDef& struct_def) {
+  std::vector<std::string> GenerateCodingKeys(const StructDef& struct_def) {
-    code_ += "enum CodingKeys: String, CodingKey {";
+    std::vector<std::string> coding_keys;
-    Indent();
     for (auto it = struct_def.fields.vec.begin();
          it != struct_def.fields.vec.end(); ++it) {
       const auto& field = **it;
       if (field.deprecated) continue;
-
+      coding_keys.push_back("case " + namer_.Variable(field) + " = \"" +
-      code_.SetValue("RAWVALUENAME", field.name);
+                            field.name + "\"");
-      code_.SetValue("FIELDVAR", namer_.Variable(field));
-      code_ += "case {{FIELDVAR}} = \"{{RAWVALUENAME}}\"";
     }
-    Outdent();
+    return coding_keys;
-    code_ += "}";
   }
 
   void GenerateEncoderUnionBody(const FieldDef& field) {
@@ -1092,14 +1101,31 @@ class SwiftGenerator : public BaseGenerator {
     GenOSVersionChecks();
     code_ += "extension {{STRUCTNAME}}: Encodable {";
     Indent();
-    code_ += "";
+    auto coding_keys = GenerateCodingKeys(struct_def);
-    if (struct_def.fields.vec.empty() == false) GenerateCodingKeys(struct_def);
 
-    code_ += "{{ACCESS_TYPE}} func encode(to encoder: Encoder) throws {";
+    if (coding_keys.empty() == false) {
+      code_ += "enum CodingKeys: String, CodingKey {";
       Indent();
-    if (struct_def.fields.vec.empty() == false) GenerateEncoderBody(struct_def);
+      for (auto it = coding_keys.begin(); it != coding_keys.end(); ++it) {
+        const auto& field = *it;
+        code_ += field;
+      }
       Outdent();
       code_ += "}";
+
+      code_ += "";
+    }
+
+    code_ += "{{ACCESS_TYPE}} func encode(to encoder: Encoder) throws {";
+
+    if (coding_keys.empty() == false) {
+      Indent();
+      GenerateEncoderBody(struct_def);
+      Outdent();
+    }
+
+    code_ += "}";
+
     Outdent();
     code_ += "}";
     code_ += "";
@@ -1129,7 +1155,7 @@ class SwiftGenerator : public BaseGenerator {
       }
 
       code_ +=
-          "try _v.visit(field: {{TABLEOFFSET}}.{{OFFSET}}.p, fieldName: "
+          "try _v.visit(field: {{TABLEOFFSET}}.{{OFFSET}}, fieldName: "
           "\"{{FIELDVAR}}\", required: {{ISREQUIRED}}, type: "
           "{{VALUETYPE}}.self)";
     }
@@ -1149,8 +1175,9 @@ class SwiftGenerator : public BaseGenerator {
     code_.SetValue("VALUETYPE", namer_.NamespacedType(union_def));
     code_.SetValue("FUNCTION_NAME", is_vector ? "visitUnionVector" : "visit");
     code_ +=
-        "try _v.{{FUNCTION_NAME}}(unionKey: {{TABLEOFFSET}}.{{OFFSET}}Type.p, "
+        "try _v.{{FUNCTION_NAME}}(unionKey: "
-        "unionField: {{TABLEOFFSET}}.{{OFFSET}}.p, unionKeyName: "
+        "{{TABLEOFFSET}}.{{OFFSET}}Type, "
+        "unionField: {{TABLEOFFSET}}.{{OFFSET}}, unionKeyName: "
         "\"{{FIELDVAR}}Type\", fieldName: \"{{FIELDVAR}}\", required: "
         "{{ISREQUIRED}}, completion: { (verifier, key: {{VALUETYPE}}, pos) in";
     Indent();
@@ -1625,15 +1652,23 @@ class SwiftGenerator : public BaseGenerator {
         buffer_constructor.push_back(field_var + " = _t." + field_field);
 
         if (field.IsRequired()) {
-          std::string default_value =
+          std::string default_value;
-              field.IsDefault() ? SwiftConstant(field) : "";
+          if (field.IsDefault()) {
-          base_constructor.push_back(field_var + " = \"" + default_value +
+            const auto sc = SwiftConstant(field);
-                                     "\"");
+            flatbuffers::EscapeString(sc.c_str(), sc.length(), &default_value,
+                                      true, false);
+          } else {
+            default_value = "\"\"";
+          }
+          base_constructor.push_back(field_var + " = " + default_value);
           break;
         }
         if (field.IsDefault() && !field.IsRequired()) {
-          std::string value = field.IsDefault() ? SwiftConstant(field) : "nil";
+          const auto sc = SwiftConstant(field);
-          base_constructor.push_back(field_var + " = \"" + value + "\"");
+          std::string value;
+          flatbuffers::EscapeString(sc.c_str(), sc.length(), &value,
+                                    true, false);
+          base_constructor.push_back(field_var + " = " + value);
         }
         break;
       }
@@ -1892,7 +1927,7 @@ class SwiftGenerator : public BaseGenerator {
   }
 
   std::string GenOffset() {
-    return "let o = {{ACCESS}}.offset({{TABLEOFFSET}}.{{OFFSET}}.v); ";
+    return "let o = {{ACCESS}}.offset({{TABLEOFFSET}}.{{OFFSET}}); ";
   }
 
   std::string GenReaderMainBody(const std::string& optional = "") {

src/idl_gen_ts.cpp

@@ -67,6 +67,7 @@ Namer::Config TypeScriptDefaultConfig() {
           /*object_suffix=*/"T",
           /*keyword_prefix=*/"",
           /*keyword_suffix=*/"_",
+          /*keywords_casing=*/Namer::Config::KeywordsCasing::CaseSensitive,
           /*filenames=*/Case::kDasher,
           /*directories=*/Case::kDasher,
           /*output_path=*/"",
@@ -86,6 +87,7 @@ std::set<std::string> TypescriptKeywords() {
       "throw",     "true",     "try",       "typeof",     "var",        "void",
       "while",     "with",     "as",        "implements", "interface",  "let",
       "package",   "private",  "protected", "public",     "static",     "yield",
+      "undefined"  // Used with --ts-undefined-for-optionals
   };
 }
 
@@ -110,7 +112,9 @@ class TsGenerator : public BaseGenerator {
               const std::string& file_name)
       : BaseGenerator(parser, path, file_name, "", "_", "ts"),
         namer_(WithFlagOptions(TypeScriptDefaultConfig(), parser.opts, path),
-               TypescriptKeywords()) {}
+               TypescriptKeywords()),
+        null_keyword_(parser_.opts.ts_undefined_for_optionals ? "undefined"
+                                                              : "null") {}
 
   bool generate() {
     generateEnums();
@@ -214,6 +218,8 @@ class TsGenerator : public BaseGenerator {
 
   std::map<std::string, NsDefinition> ns_defs_;
 
+  std::string null_keyword_;
+
   // Generate code for all enums.
   void generateEnums() {
     for (auto it = parser_.enums_.vec.begin(); it != parser_.enums_.vec.end();
@@ -318,11 +324,12 @@ class TsGenerator : public BaseGenerator {
         export_counter++;
       }
 
-      if (export_counter > 0)
+      if (export_counter > 0) {
         parser_.opts.file_saver->SaveFile(it.second.filepath.c_str(), code,
                                           false);
       }
     }
+  }
 
   // Generate a documentation comment, if available.
   static void GenDocComment(const std::vector<std::string>& dc,
@@ -467,7 +474,7 @@ class TsGenerator : public BaseGenerator {
 
   std::string GenDefaultValue(const FieldDef& field, import_set& imports) {
     if (field.IsScalarOptional()) {
-      return "null";
+      return null_keyword_;
     }
 
     const auto& value = field.value;
@@ -515,10 +522,23 @@ class TsGenerator : public BaseGenerator {
       case BASE_TYPE_BOOL:
         return value.constant == "0" ? "false" : "true";
 
-      case BASE_TYPE_STRING:
+      case BASE_TYPE_STRING: {
+        // NOTE: Strings without a default value are parsed as "0" by
+        // the parser, so therefore we have to treat "0" as a null-signifying
+        // value.
+        if (value.constant == "0" || value.constant == "null") {
+          return "null";
+        } else {
+          std::string escaped;
+          flatbuffers::EscapeString(value.constant.c_str(),
+                                    value.constant.length(), &escaped,
+                                    true, false);
+          return escaped;
+        }
+      }
       case BASE_TYPE_UNION:
       case BASE_TYPE_STRUCT: {
-        return "null";
+        return null_keyword_;
       }
 
       case BASE_TYPE_ARRAY:
@@ -554,16 +574,16 @@ class TsGenerator : public BaseGenerator {
         } else {
           name = AddImport(imports, owner, *type.struct_def).name;
         }
-        return allowNull ? (name + "|null") : name;
+        return allowNull ? (name + "|" + null_keyword_) : name;
       }
     }
 
     switch (type.base_type) {
       case BASE_TYPE_BOOL:
-        return allowNull ? "boolean|null" : "boolean";
+        return allowNull ? ("boolean|" + null_keyword_) : "boolean";
       case BASE_TYPE_LONG:
       case BASE_TYPE_ULONG:
-        return allowNull ? "bigint|null" : "bigint";
+        return allowNull ? ("bigint|" + null_keyword_) : "bigint";
       case BASE_TYPE_ARRAY: {
         std::string name;
         if (type.element == BASE_TYPE_LONG || type.element == BASE_TYPE_ULONG) {
@@ -578,16 +598,16 @@ class TsGenerator : public BaseGenerator {
           }
         }
 
-        return name + (allowNull ? "|null" : "");
+        return name + (allowNull ? ("|" + null_keyword_) : "");
       }
       default:
         if (IsScalar(type.base_type)) {
           if (type.enum_def) {
             const auto enum_name =
                 AddImport(imports, owner, *type.enum_def).name;
-            return allowNull ? (enum_name + "|null") : enum_name;
+            return allowNull ? (enum_name + "|" + null_keyword_) : enum_name;
           }
-          return allowNull ? "number|null" : "number";
+          return allowNull ? ("number|" + null_keyword_) : "number";
         }
         return "flatbuffers.Offset";
     }
@@ -641,7 +661,8 @@ class TsGenerator : public BaseGenerator {
   }
 
   void GenStructArgs(import_set& imports, const StructDef& struct_def,
-                     std::string* arguments, const std::string& nameprefix) {
+                     const Definition& owner, std::string* arguments,
+                     const std::string& nameprefix) {
     for (auto it = struct_def.fields.vec.begin();
          it != struct_def.fields.vec.end(); ++it) {
       auto& field = **it;
@@ -649,11 +670,11 @@ class TsGenerator : public BaseGenerator {
         // Generate arguments for a struct inside a struct. To ensure names
         // don't clash, and to make it obvious these arguments are constructing
         // a nested struct, prefix the name with the field name.
-        GenStructArgs(imports, *field.value.type.struct_def, arguments,
+        GenStructArgs(imports, *field.value.type.struct_def, owner, arguments,
                       nameprefix + field.name + "_");
       } else {
         *arguments += ", " + nameprefix + field.name + ": " +
-                      GenTypeName(imports, field, field.value.type, true,
+                      GenTypeName(imports, owner, field.value.type, true,
                                   field.IsOptional());
       }
     }
@@ -915,6 +936,48 @@ class TsGenerator : public BaseGenerator {
     return symbols_expression;
   }
 
+  std::vector<std::string> PathComponents(const std::string& path) const {
+    std::vector<std::string> components;
+    size_t start = 0;
+    while (start < path.size()) {
+      auto end = path.find(kPathSeparator, start);
+      if (end == std::string::npos) end = path.size();
+      if (end > start) {
+        components.emplace_back(path.substr(start, end - start));
+      }
+      if (end == path.size()) break;
+      start = end + 1;
+    }
+    return components;
+  }
+
+  std::string RelativeDirectory(const std::vector<std::string>& from,
+                                const std::vector<std::string>& to) const {
+    size_t common = 0;
+    while (common < from.size() && common < to.size() &&
+           from[common] == to[common]) {
+      ++common;
+    }
+
+    std::string rel;
+    const size_t ups = from.size() - common;
+    if (ups == 0) {
+      rel = ".";
+    } else {
+      for (size_t i = 0; i < ups; ++i) {
+        if (!rel.empty()) rel += kPathSeparator;
+        rel += "..";
+      }
+    }
+
+    for (size_t i = common; i < to.size(); ++i) {
+      if (!rel.empty()) rel += kPathSeparator;
+      rel += to[i];
+    }
+
+    return rel;
+  }
+
   template <typename DefinitionT>
   ImportDefinition AddImport(import_set& imports, const Definition& dependent,
                              const DefinitionT& dependency) {
@@ -942,26 +1005,32 @@ class TsGenerator : public BaseGenerator {
     const std::string symbols_expression = GenSymbolExpression(
         dependency, has_name_clash, import_name, name, object_name);
 
-    std::string bare_file_path;
+    const Namespace* dependent_ns = dependent.defined_namespace
-    std::string rel_file_path;
+                                        ? dependent.defined_namespace
-    if (dependent.defined_namespace) {
+                                        : parser_.empty_namespace_;
-      const auto& dep_comps = dependent.defined_namespace->components;
+    const Namespace* dependency_ns = dependency.defined_namespace
-      for (size_t i = 0; i < dep_comps.size(); i++) {
+                                         ? dependency.defined_namespace
-        rel_file_path += i == 0 ? ".." : (kPathSeparator + std::string(".."));
+                                         : parser_.empty_namespace_;
-      }
-      if (dep_comps.size() == 0) {
-        rel_file_path += ".";
-      }
-    } else {
-      rel_file_path += "..";
-    }
 
-    bare_file_path +=
+    const std::string dependent_dirs =
-        kPathSeparator +
+        namer_.Directories(*dependent_ns, SkipDir::OutputPath);
-        namer_.Directories(dependency.defined_namespace->components,
+    const std::string dependency_dirs =
-                           SkipDir::OutputPath) +
+        namer_.Directories(*dependency_ns, SkipDir::OutputPath);
+
+    const auto dependent_components = PathComponents(dependent_dirs);
+    const auto dependency_components = PathComponents(dependency_dirs);
+
+    std::string rel_dir =
+        RelativeDirectory(dependent_components, dependency_components);
+    if (rel_dir.empty()) rel_dir = ".";
+    if (!rel_dir.empty()) rel_dir += kPathSeparator;
+
+    std::string rel_file_path =
+        rel_dir + namer_.File(dependency, SkipFile::SuffixAndExtension);
+
+    std::string bare_file_path =
+        kPathSeparator + dependency_dirs +
         namer_.File(dependency, SkipFile::SuffixAndExtension);
-    rel_file_path += bare_file_path;
 
     ImportDefinition import;
     import.name = name;
@@ -1039,7 +1108,8 @@ class TsGenerator : public BaseGenerator {
       const auto& enum_def = *union_type.enum_def;
 
       const auto valid_union_type = GenUnionTypeTS(enum_def, imports);
-      const auto valid_union_type_with_null = valid_union_type + "|null";
+      const auto valid_union_type_with_null =
+          valid_union_type + "|" + null_keyword_;
 
       auto ret = "\n\nexport function " + GenUnionConvFuncName(enum_def) +
                  "(\n  type: " + GetTypeName(enum_def) +
@@ -1051,7 +1121,7 @@ class TsGenerator : public BaseGenerator {
 
       const auto union_enum_loop = [&](const std::string& accessor_str) {
         ret += "  switch(" + enum_type + "[type]) {\n";
-        ret += "    case 'NONE': return null; \n";
+        ret += "    case 'NONE': return " + null_keyword_ + "; \n";
 
         for (auto it = enum_def.Vals().begin(); it != enum_def.Vals().end();
              ++it) {
@@ -1075,7 +1145,7 @@ class TsGenerator : public BaseGenerator {
           ret += "\n";
         }
 
-        ret += "    default: return null;\n";
+        ret += "    default: return " + null_keyword_ + ";\n";
         ret += "  }\n";
       };
 
@@ -1120,7 +1190,8 @@ class TsGenerator : public BaseGenerator {
         ret += "      const temp = " + conversion_function + "(this." +
                namer_.Method(field_name, "Type") + "(), " +
                field_binded_method + ");\n";
-        ret += "      if(temp === null) { return null; }\n";
+        ret += "      if(temp === " + null_keyword_ + ") { return " +
+               null_keyword_ + "; }\n";
         ret += union_has_string
                    ? "      if(typeof temp === 'string') { return temp; }\n"
                    : "";
@@ -1140,12 +1211,12 @@ class TsGenerator : public BaseGenerator {
                "++targetEnumIndex) {\n";
         ret += "      const targetEnum = this." +
                namer_.Method(field_name, "Type") + "(targetEnumIndex);\n";
-        ret += "      if(targetEnum === null || " + enum_type +
+        ret += "      if(targetEnum === " + null_keyword_ + " || " + enum_type +
                "[targetEnum!] === 'NONE') { "
                "continue; }\n\n";
         ret += "      const temp = " + conversion_function + "(targetEnum, " +
                field_binded_method + ", targetEnumIndex);\n";
-        ret += "      if(temp === null) { continue; }\n";
+        ret += "      if(temp === " + null_keyword_ + ") { continue; }\n";
         ret += union_has_string ? "      if(typeof temp === 'string') { "
                                   "ret.push(temp); continue; }\n"
                                 : "";
@@ -1162,11 +1233,12 @@ class TsGenerator : public BaseGenerator {
     return "";
   }
 
-  static std::string GenNullCheckConditional(
+  std::string GenNullCheckConditional(const std::string& nullCheckVar,
-      const std::string& nullCheckVar, const std::string& trueVal,
+                                      const std::string& trueVal,
-      const std::string& falseVal = "null") {
+                                      const std::string& falseVal = "") {
-    return "(" + nullCheckVar + " !== null ? " + trueVal + " : " + falseVal +
+    std::string false_val = falseVal.empty() ? null_keyword_ : falseVal;
-           ")";
+    return "(" + nullCheckVar + " !== " + null_keyword_ + " ? " + trueVal +
+           " : " + false_val + ")";
   }
 
   std::string GenStructMemberValueTS(const StructDef& struct_def,
@@ -1275,10 +1347,9 @@ class TsGenerator : public BaseGenerator {
       // Emit a scalar field
       const auto is_string = IsString(field.value.type);
       if (IsScalar(field.value.type.base_type) || is_string) {
-        const auto has_null_default = is_string || HasNullDefault(field);
+        field_type +=
-
+            GenTypeName(imports, field, field.value.type, false,
-        field_type += GenTypeName(imports, field, field.value.type, false,
+                        !HasDefaultValue(field) || HasNullDefault(field));
-                                  has_null_default);
         field_val = "this." + namer_.Method(field) + "()";
 
         if (field.value.type.base_type != BASE_TYPE_STRING) {
@@ -1300,8 +1371,8 @@ class TsGenerator : public BaseGenerator {
 
             const std::string field_accessor =
                 "this." + namer_.Method(field) + "()";
-            field_val = GenNullCheckConditional(field_accessor,
+            field_val = GenNullCheckConditional(
-                                                field_accessor + "!.unpack()");
+                field_accessor, field_accessor + "!.unpack()", null_keyword_);
             auto packing = GenNullCheckConditional(
                 "this." + field_field,
                 "this." + field_field + "!.pack(builder)", "0");
@@ -1509,8 +1580,8 @@ class TsGenerator : public BaseGenerator {
             break;
         }
 
-        // length 0 vector is simply empty instead of null
+        // length 0 vector is simply empty instead of null/undefined.
-        field_type += is_vector ? "" : "|null";
+        field_type += is_vector ? "" : ("|" + null_keyword_);
       }
 
       if (!field_offset_decl.empty()) {
@@ -1539,7 +1610,7 @@ class TsGenerator : public BaseGenerator {
         } else {
           if (field.IsScalarOptional()) {
             pack_func_create_call +=
-                "  if (" + field_offset_val + " !== null)\n  ";
+                "  if (" + field_offset_val + " !== " + null_keyword_ + ")\n  ";
           }
           pack_func_create_call += "  " + struct_name + "." +
                                    namer_.Method("add", field) + "(builder, " +
@@ -1624,12 +1695,14 @@ class TsGenerator : public BaseGenerator {
     GenDocComment(struct_def.doc_comment, code_ptr);
     code += "export class ";
     code += object_name;
-    if (parser.opts.generate_object_based_api)
+    if (parser.opts.generate_object_based_api) {
       code += " implements flatbuffers.IUnpackableObject<" + object_api_name +
               "> {\n";
-    else
+    } else {
       code += " {\n";
-    code += "  bb: flatbuffers.ByteBuffer|null = null;\n";
+    }
+    code += "  bb: flatbuffers.ByteBuffer|" + null_keyword_ + " = " +
+            null_keyword_ + ";\n";
     code += "  bb_pos = 0;\n";
 
     // Generate the __init method that sets the field in a pre-existing
@@ -1670,21 +1743,22 @@ class TsGenerator : public BaseGenerator {
         offset_prefix = "  const offset = " + GenBBAccess() +
                         ".__offset(this.bb_pos, " +
                         NumToString(field.value.offset) + ");\n";
-        offset_prefix += "  return offset ? ";
+        offset_prefix += "  return ";
       }
 
       // Emit a scalar field
       const auto is_string = IsString(field.value.type);
       if (IsScalar(field.value.type.base_type) || is_string) {
-        const auto has_null_default = is_string || HasNullDefault(field);
+        const auto has_null_default =
+            !field.IsRequired() && !HasDefaultValue(field);
 
         GenDocComment(field.doc_comment, code_ptr);
         std::string prefix = namer_.Method(field) + "(";
         if (is_string) {
-          code += prefix + "):string|null\n";
+          code += prefix + "):" + (has_null_default ? "string|" + null_keyword_ : "string") + "\n";
           code +=
               prefix + "optionalEncoding:flatbuffers.Encoding" + "):" +
-              GenTypeName(imports, struct_def, field.value.type, false, true) +
+              GenTypeName(imports, struct_def, field.value.type, false, has_null_default) +
               "\n";
           code += prefix + "optionalEncoding?:any";
         } else {
@@ -1713,9 +1787,16 @@ class TsGenerator : public BaseGenerator {
           if (is_string) {
             index += ", optionalEncoding";
           }
+          if (field.IsRequired()) {
             code +=
                 offset_prefix + GenGetter(field.value.type, "(" + index + ")");
-          if (field.value.type.base_type != BASE_TYPE_ARRAY) {
+            ;
+          } else {
+            code += offset_prefix + "offset ? " +
+                    GenGetter(field.value.type, "(" + index + ")");
+          }
+          if (field.value.type.base_type != BASE_TYPE_ARRAY &&
+              !field.IsRequired()) {
             code += " : " + GenDefaultValue(field, imports);
           }
           code += ";\n";
@@ -1731,7 +1812,8 @@ class TsGenerator : public BaseGenerator {
                     .name;
             GenDocComment(field.doc_comment, code_ptr);
             code += namer_.Method(field);
-            code += "(obj?:" + type + "):" + type + "|null {\n";
+            code +=
+                "(obj?:" + type + "):" + type + "|" + null_keyword_ + " {\n";
 
             if (struct_def.fixed) {
               code += "  return (obj || " + GenerateNewExpression(type);
@@ -1739,12 +1821,12 @@ class TsGenerator : public BaseGenerator {
               code +=
                   MaybeAdd(field.value.offset) + ", " + GenBBAccess() + ");\n";
             } else {
-              code += offset_prefix + "(obj || " + GenerateNewExpression(type) +
+              code += offset_prefix + "offset ? (obj || " +
-                      ").__init(";
+                      GenerateNewExpression(type) + ").__init(";
               code += field.value.type.struct_def->fixed
                           ? "this.bb_pos + offset"
                           : GenBBAccess() + ".__indirect(this.bb_pos + offset)";
-              code += ", " + GenBBAccess() + ") : null;\n";
+              code += ", " + GenBBAccess() + ") : " + null_keyword_ + ";\n";
             }
 
             break;
@@ -1797,7 +1879,7 @@ class TsGenerator : public BaseGenerator {
             } else {
               code += prefix;
             }
-            code += "):" + vectortypename + "|null {\n";
+            code += "):" + vectortypename + "|" + null_keyword_ + " {\n";
 
             if (vectortype.base_type == BASE_TYPE_STRUCT) {
               code += offset_prefix + "(obj || " +
@@ -1837,7 +1919,7 @@ class TsGenerator : public BaseGenerator {
                     code += " : 0";
                   }
                 } else {
-                  code += ": null";
+                  code += ": " + null_keyword_;
                 }
                 break;
               }
@@ -1895,10 +1977,10 @@ class TsGenerator : public BaseGenerator {
             } else {
               code += prefix;
             }
-            code += "):" + vectortypename + "|null {\n";
+            code += "):" + vectortypename + "|" + null_keyword_ + " {\n";
 
             if (vectortype.base_type == BASE_TYPE_STRUCT) {
-              code += offset_prefix + "(obj || " +
+              code += offset_prefix + "offset ? (obj || " +
                       GenerateNewExpression(vectortypename);
               code += ").__init(";
               code += vectortype.struct_def->fixed
@@ -1911,7 +1993,8 @@ class TsGenerator : public BaseGenerator {
               } else if (IsString(vectortype)) {
                 index += ", optionalEncoding";
               }
-              code += offset_prefix + GenGetter(vectortype, "(" + index + ")");
+              code += offset_prefix + "offset ? " +
+                      GenGetter(vectortype, "(" + index + ")");
             }
             code += " : ";
             if (field.value.type.element == BASE_TYPE_BOOL) {
@@ -1921,12 +2004,12 @@ class TsGenerator : public BaseGenerator {
               code += "BigInt(0)";
             } else if (IsScalar(field.value.type.element)) {
               if (field.value.type.enum_def) {
-                code += "null";
+                code += null_keyword_;
               } else {
                 code += "0";
               }
             } else {
-              code += "null";
+              code += null_keyword_;
             }
             code += ";\n";
             break;
@@ -1939,13 +2022,13 @@ class TsGenerator : public BaseGenerator {
             const auto& union_enum = *(field.value.type.enum_def);
             const auto union_type = GenUnionGenericTypeTS(union_enum);
             code += "<T extends flatbuffers.Table>(obj:" + union_type +
-                    "):" + union_type +
+                    "):" + union_type + "|" + null_keyword_ +
-                    "|null "
+                    " "
                     "{\n";
 
-            code += offset_prefix +
+            code += offset_prefix + "offset ? " +
                     GenGetter(field.value.type, "(obj, this.bb_pos + offset)") +
-                    " : null;\n";
+                    " : " + null_keyword_ + ";\n";
             break;
           }
           default:
@@ -1996,7 +2079,7 @@ class TsGenerator : public BaseGenerator {
         // Emit a length helper
         GenDocComment(code_ptr);
         code += namer_.Method(field, "Length");
-        code += "():number {\n" + offset_prefix;
+        code += "():number {\n" + offset_prefix + "offset ? ";
 
         code +=
             GenBBAccess() + ".__vector_len(this.bb_pos + offset) : 0;\n}\n\n";
@@ -2007,14 +2090,30 @@ class TsGenerator : public BaseGenerator {
           GenDocComment(code_ptr);
 
           code += namer_.Method(field, "Array");
-          code +=
-              "():" + GenType(vectorType) + "Array|null {\n" + offset_prefix;
 
-          code += "new " + GenType(vectorType) + "Array(" + GenBBAccess() +
+          std::string return_type =
-                  ".bytes().buffer, " + GenBBAccess() +
+              (field.IsRequired() || HasDefaultValue(field))
+                  ? "Array"
+                  : ("Array|" + null_keyword_);
+          if (field.IsRequired()) {
+            code += "():" + GenType(vectorType) + return_type + " {\n" +
+                    offset_prefix + "new " + GenType(vectorType) + "Array(" +
+                    GenBBAccess() + ".bytes().buffer, " + GenBBAccess() +
                     ".bytes().byteOffset + " + GenBBAccess() +
                     ".__vector(this.bb_pos + offset), " + GenBBAccess() +
-                  ".__vector_len(this.bb_pos + offset)) : null;\n}\n\n";
+                    ".__vector_len(this.bb_pos + offset));\n}\n\n";
+          } else {
+            std::string value = HasDefaultValue(field)
+                                    ? "new " + GenType(vectorType) + "Array()"
+                                    : "null";
+            code += "():" + GenType(vectorType) + return_type + " {\n" +
+                    offset_prefix + "offset ? new " + GenType(vectorType) +
+                    "Array(" + GenBBAccess() + ".bytes().buffer, " +
+                    GenBBAccess() + ".bytes().byteOffset + " + GenBBAccess() +
+                    ".__vector(this.bb_pos + offset), " + GenBBAccess() +
+                    ".__vector_len(this.bb_pos + offset)) : " + value +
+                    ";\n}\n\n";
+          }
         }
       }
     }
@@ -2043,7 +2142,7 @@ class TsGenerator : public BaseGenerator {
     // Emit a factory constructor
     if (struct_def.fixed) {
       std::string arguments;
-      GenStructArgs(imports, struct_def, &arguments, "");
+      GenStructArgs(imports, struct_def, struct_def, &arguments, "");
       GenDocComment(code_ptr);
 
       code += "static create" + GetPrefixedName(struct_def) +
@@ -2084,7 +2183,7 @@ class TsGenerator : public BaseGenerator {
         if (!IsScalar(field.value.type.base_type)) {
           code += "0";
         } else if (HasNullDefault(field)) {
-          code += "null";
+          code += null_keyword_;
         } else {
           if (field.value.type.base_type == BASE_TYPE_BOOL) {
             code += "+";
@@ -2201,7 +2300,7 @@ class TsGenerator : public BaseGenerator {
           const auto arg_name = GetArgName(field);
 
           if (field.IsScalarOptional()) {
-            code += "  if (" + arg_name + " !== null)\n  ";
+            code += "  if (" + arg_name + " !== " + null_keyword_ + ")\n  ";
           }
 
           code += "  " + methodPrefix + "." + namer_.Method("add", field) + "(";
@@ -2241,10 +2340,38 @@ class TsGenerator : public BaseGenerator {
     }
   }
 
-  static bool HasNullDefault(const FieldDef& field) {
+  bool HasNullDefault(const FieldDef& field) {
     return field.IsOptional() && field.value.constant == "null";
   }
 
+  static bool HasDefaultValue(const FieldDef& field) {
+    switch (field.value.type.base_type) {
+      // These types can't have defaults
+      case BASE_TYPE_UNION:
+      case BASE_TYPE_STRUCT: {
+        return false;
+      }
+
+      // Arrays always have a default (empty array)
+      case BASE_TYPE_ARRAY:
+        return true;
+
+      // The only supported default for vectors is []
+      case BASE_TYPE_VECTOR:
+        return field.value.constant == "[]";
+
+      // Even strings are presumed to be null-default if the default value is
+      // "0", this is intended behavior.
+      case BASE_TYPE_STRING: {
+        return field.value.constant != "0" && field.value.constant != "null";
+      }
+
+      default: {
+        return field.value.constant != "null";
+      }
+    }
+  }
+
   std::string GetArgType(import_set& imports, const Definition& owner,
                          const FieldDef& field, bool allowNull) {
     return GenTypeName(imports, owner, field.value.type, true,

src/idl_parser.cpp

@@ -2755,6 +2755,42 @@ std::vector<IncludedFile> Parser::GetIncludedFiles() const {
   return {it->second.cbegin(), it->second.cend()};
 }
 
+bool Parser::HasCircularStructDependency() {
+  std::function<bool(StructDef*)> visit =
+      [&](StructDef* struct_def) {
+        // Only consider fixed structs and structs we have yet to check
+        if (!struct_def->fixed || struct_def->cycle_status == StructDef::CycleStatus::Checked) {
+          return false;
+        }
+
+        if (struct_def->cycle_status == StructDef::CycleStatus::InProgress) {
+          // cycle found
+          return true;
+        }
+
+        struct_def->cycle_status = StructDef::CycleStatus::InProgress;
+
+        for (const auto& field : struct_def->fields.vec) {
+          if (field->value.type.base_type == BASE_TYPE_STRUCT) {
+            if (visit(field->value.type.struct_def)) {
+              return true;  // Cycle detected in recursion.
+            }
+          }
+        }
+
+        struct_def->cycle_status = StructDef::CycleStatus::Checked;
+        return false;  // No cycle detected.
+      };
+
+  for (const auto& struct_def : structs_.vec) {
+    if (visit(struct_def)) {
+      return true;  // Cycle detected.
+    }
+  }
+
+  return false;  // No cycle detected.
+}
+
 bool Parser::SupportsOptionalScalars(const flatbuffers::IDLOptions& opts) {
   static FLATBUFFERS_CONSTEXPR unsigned long supported_langs =
       IDLOptions::kRust | IDLOptions::kSwift | IDLOptions::kLobster |
@@ -2773,7 +2809,8 @@ bool Parser::SupportsOptionalScalars() const {
 bool Parser::SupportsDefaultVectorsAndStrings() const {
   static FLATBUFFERS_CONSTEXPR unsigned long supported_langs =
       IDLOptions::kRust | IDLOptions::kSwift | IDLOptions::kNim |
-      IDLOptions::kCpp | IDLOptions::kBinary | IDLOptions::kJson;
+      IDLOptions::kCpp | IDLOptions::kBinary | IDLOptions::kJson |
+      IDLOptions::kTs;
   return !(opts.lang_to_generate & ~supported_langs);
 }
 
@@ -3135,8 +3172,10 @@ CheckedError Parser::ParseProtoFields(StructDef* struct_def, bool isextend,
             return Error("Protobuf has non positive number in reserved ids");
 
           if (range) {
-            for (voffset_t id = from + 1; id <= attribute; id++)
+            for (uint32_t id = static_cast<uint32_t>(from) + 1;
-              struct_def->reserved_ids.push_back(id);
+                 id <= static_cast<uint32_t>(attribute); id++) {
+              struct_def->reserved_ids.push_back(static_cast<voffset_t>(id));
+            }
 
             range = false;
           } else {

src/reflection.cpp

@@ -156,6 +156,7 @@ static bool VerifyVector(flatbuffers::Verifier& v,
       auto type_vec = table.GetPointer<Vector<uint8_t>*>(vec_field.offset() -
                                                          sizeof(voffset_t));
       if (!v.VerifyVector(type_vec)) return false;
+      if (type_vec->size() != vec->size()) return false;
       for (uoffset_t j = 0; j < vec->size(); j++) {
         //  get union type from the prev field
         auto utype = type_vec->Get(j);
@@ -640,7 +641,10 @@ const uint8_t* AddFlatBuffer(std::vector<uint8_t>& flatbuf,
                              const uint8_t* newbuf, size_t newlen) {
   // Align to sizeof(uoffset_t) past sizeof(largest_scalar_t) since we're
   // going to chop off the root offset.
+  if (!newbuf || newlen < sizeof(uoffset_t)) return nullptr;
   FLATBUFFERS_ASSERT(newlen >= sizeof(uoffset_t));
+  auto root = ReadScalar<uoffset_t>(newbuf);
+  if (root < sizeof(uoffset_t) || root >= newlen) return nullptr;
   while ((flatbuf.size() & (sizeof(uoffset_t) - 1)) ||
          !(flatbuf.size() & (sizeof(largest_scalar_t) - 1))) {
     flatbuf.push_back(0);
@@ -648,7 +652,7 @@ const uint8_t* AddFlatBuffer(std::vector<uint8_t>& flatbuf,
   auto insertion_point = static_cast<uoffset_t>(flatbuf.size());
   // Insert the entire FlatBuffer minus the root pointer.
   flatbuf.insert(flatbuf.end(), newbuf + sizeof(uoffset_t), newbuf + newlen);
-  auto root_offset = ReadScalar<uoffset_t>(newbuf) - sizeof(uoffset_t);
+  auto root_offset = root - sizeof(uoffset_t);
   return flatbuf.data() + insertion_point + root_offset;
 }
 

swift/BUILD.bazel

@@ -14,7 +14,8 @@ swift_library(
     name = "swift",
     srcs = glob([
         "Sources/FlatBuffers/*.swift",
-        "Sources/Common/*.swift",
+        "Sources/FlatBuffers/Vectors/*.swift",
+        "Sources/Common/*.swift"
     ]),
     module_name = "FlatBuffers",
     visibility = ["//visibility:public"],

swift/Sources/FlatBuffers/Table.swift

@@ -49,7 +49,7 @@ public struct Table {
   /// the vtable
   /// - Parameter o: current offset
   /// - Returns: offset of field within buffer
-  public func offset(_ o: Int32) -> Int32 {
+  public func offset(_ o: VOffset) -> Int32 {
     let vtable = position &- bb.read(def: Int32.self, position: Int(position))
     return o
       < bb
@@ -57,7 +57,7 @@ public struct Table {
       ? Int32(
         bb.read(
           def: Int16.self,
-          position: Int(vtable &+ o))) : 0
+          position: Int(vtable &+ Int32(o)))) : 0
   }
 
   /// Gets the indirect offset of the current stored object
@@ -106,13 +106,13 @@ public struct Table {
   /// This should only be used by `Scalars`
   /// - Parameter off: Readable offset
   /// - Returns: Returns a vector of type [T]
-  public func getVector<T>(at off: Int32) -> [T]? {
+  public func getVector<T>(at off: VOffset) -> [T]? {
     let o = offset(off)
     guard o != 0 else { return nil }
     return bb.readSlice(index: Int(vector(at: o)), count: Int(vector(count: o)))
   }
 
-  public func vector<T>(at off: Int32, byteSize: Int) -> FlatbufferVector<T> {
+  public func vector<T>(at off: VOffset, byteSize: Int) -> FlatbufferVector<T> {
     let off = offset(off)
     return FlatbufferVector(
       bb: bb,
@@ -122,7 +122,7 @@ public struct Table {
   }
 
   public func unionVector(
-    at off: Int32,
+    at off: VOffset,
     byteSize: Int) -> UnionFlatbufferVector
   {
     let off = offset(off)
@@ -146,7 +146,7 @@ public struct Table {
   /// - Returns: Returns a pointer to the underlying data
   @inline(__always)
   public func withUnsafePointerToSlice<T>(
-    at off: Int32,
+    at off: VOffset,
     body: (UnsafeRawBufferPointer, Int) throws -> T) rethrows -> T?
   {
     let o = offset(off)

swift/Sources/FlexBuffers/Reader/Reference.swift

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import Common
 import Foundation
 
 enum FlexBuffersErrors: Error {
@@ -23,6 +24,10 @@ enum FlexBuffersErrors: Error {
 
 @inline(__always)
 public func getRoot(buffer: ByteBuffer) throws -> Reference? {
+  assert(
+    isLitteEndian,
+    "Swift FlexBuffers currently only supports little-endian systems")
+
   let end = buffer.count
   if buffer.count < 3 {
     throw FlexBuffersErrors.sizeOfBufferIsTooSmall

swift/Sources/FlexBuffers/Writer/FlexBuffersWriter.swift

@@ -37,12 +37,15 @@ public struct FlexBuffersWriter {
   private var hasDuplicatedKeys = false
   private var minBitWidth: BitWidth = .w8
   private var _bb: _InternalByteBuffer
-  private var stack: [Value] = []
+  private var stack: Stack = Stack()
   private var keyPool: [Int: UInt] = [:]
   private var stringPool: [Int: UInt] = [:]
   private var flags: BuilderFlag
 
   public init(initialSize: Int = 1024, flags: BuilderFlag = .shareKeys) {
+    assert(
+      isLitteEndian,
+      "Swift FlexBuffers currently only supports little-endian systems")
     _bb = _InternalByteBuffer(initialSize: initialSize)
     self.flags = flags
   }
@@ -148,7 +151,7 @@ public struct FlexBuffersWriter {
       typed: typed,
       fixed: fixed,
       keys: nil)
-    stack = Array(stack[..<start])
+    stack.popLast(start)
     stack.append(vec)
     return vec.u
   }
@@ -217,7 +220,7 @@ public struct FlexBuffersWriter {
       typed: false,
       fixed: false,
       keys: keys)
-    stack = Array(stack[..<start])
+    stack.popLast(start)
     stack.append(vec)
     return numericCast(vec.u)
   }
@@ -757,7 +760,7 @@ public struct FlexBuffersWriter {
     }
 
     if !fixed {
-      write(value: count, byteWidth: byteWidth)
+      write(value: UInt64(count), byteWidth: byteWidth)
     }
 
     let vloc = _bb.writerIndex
@@ -830,13 +833,14 @@ public struct FlexBuffersWriter {
       let key, value: Value
     }
 
-    stack[start...].withUnsafeMutableBytes { buffer in
+    stack.withUnsafeMutableBytes(start: start) { buffer in
       var ptr = buffer.assumingMemoryBound(to: TwoValue.self)
       ptr.sort { a, b in
         let aMem = _bb.memory.advanced(by: numericCast(a.key.u))
           .assumingMemoryBound(to: CChar.self)
         let bMem = _bb.memory.advanced(by: numericCast(b.key.u))
           .assumingMemoryBound(to: CChar.self)
+
         let comp = strcmp(aMem, bMem)
         if (comp == 0) && a != b { hasDuplicatedKeys = true }
         return comp < 0
@@ -897,3 +901,129 @@ extension FlexBuffersWriter {
     return endMap(start: start)
   }
 }
+
+fileprivate struct Stack: RandomAccessCollection {
+  typealias Element = Value
+  typealias Index = Int
+
+  private final class Storage {
+    var memory: UnsafeMutableRawPointer
+
+    init(capacity: Int, alignment: Int) {
+      memory = .allocate(byteCount: capacity, alignment: alignment)
+      memset(memory, 0, capacity)
+    }
+
+    deinit {
+      memory.deallocate()
+    }
+  }
+
+  private static let initialCapacity = 10 &* MemoryLayout<Value>.stride
+  private let storage: Storage
+  private var capacity: Int
+  private(set) var count: Int
+
+  var startIndex: Int {
+    0
+  }
+
+  var endIndex: Int {
+    count
+  }
+
+  init() {
+    count = 0
+    capacity = Self.initialCapacity
+
+    storage = Storage(
+      capacity: capacity,
+      alignment: MemoryLayout<Value>.alignment)
+  }
+
+  @inline(__always)
+  subscript(position: Int) -> Value {
+    get {
+      storage.memory.advanced(by: position &* MemoryLayout<Value>.stride)
+        .assumingMemoryBound(to: Value.self).pointee
+    }
+    set {
+      storage.memory.advanced(by: position &* MemoryLayout<Value>.stride)
+        .assumingMemoryBound(to: Value.self).pointee = newValue
+    }
+  }
+
+  @inline(__always)
+  mutating func popLast(_ val: Int) {
+    count = if val < 0 {
+      0
+    } else {
+      val
+    }
+  }
+
+  mutating func append(_ value: Value) {
+    let writePosition = count &* MemoryLayout<Value>.stride
+    if writePosition >= capacity {
+      reallocate(writePosition: writePosition)
+    }
+
+    storage.memory.advanced(by: writePosition).storeBytes(
+      of: value,
+      as: Value.self)
+    count += 1
+  }
+
+  mutating func removeAll(keepingCapacity keepCapacity: Bool = false) {
+    count = 0
+    if !keepCapacity {
+      capacity = Self.initialCapacity
+      storage.memory = UnsafeMutableRawPointer.allocate(
+        byteCount: capacity,
+        alignment: MemoryLayout<Value>.alignment)
+    }
+    memset(storage.memory, 0, capacity)
+  }
+
+  @discardableResult
+  mutating func withUnsafeMutableBytes<R>(
+    start: Int,
+    _ body: (UnsafeMutableRawBufferPointer) throws -> R) rethrows -> R
+  {
+    let startingPosition = start &* MemoryLayout<Value>.stride
+    let pointer = storage.memory.advanced(by: startingPosition)
+    return try body(UnsafeMutableRawBufferPointer(
+      start: pointer,
+      count: (count &* MemoryLayout<Value>.stride) &- startingPosition))
+  }
+
+  @discardableResult
+  mutating func withUnsafeMutableBytes<R>(
+    _ body: (UnsafeMutableRawBufferPointer) throws
+      -> R) rethrows -> R
+  {
+    return try body(UnsafeMutableRawBufferPointer(
+      start: storage.memory,
+      count: count &* MemoryLayout<Value>.stride))
+  }
+
+  mutating private func reallocate(writePosition: Int) {
+    while capacity <= writePosition {
+      capacity = capacity << 1
+    }
+
+    /// solution take from Apple-NIO
+    capacity = capacity.convertToPowerofTwo
+
+    let newData = UnsafeMutableRawPointer.allocate(
+      byteCount: capacity,
+      alignment: MemoryLayout<Value>.alignment)
+    memset(newData, 0, capacity)
+    memcpy(
+      newData,
+      storage.memory,
+      writePosition)
+    storage.memory.deallocate()
+    storage.memory = newData
+  }
+}

swift/Sources/FlexBuffers/_InternalByteBuffer.swift

@@ -60,7 +60,7 @@ struct _InternalByteBuffer {
       let newData = UnsafeMutableRawPointer.allocate(
         byteCount: capacity,
         alignment: alignment)
-      memset(newData, 0, capacity &- writerSize)
+      memset(newData, 0, capacity)
       memcpy(
         newData,
         memory,

tests/BUILD.bazel

@@ -52,6 +52,7 @@ cc_test(
         "monster_test.cpp",
         "monster_test.h",
         "monster_test_bfbs_generated.h",
+        "cross_namespace_pack_test_generated.h",
         "namespace_test/namespace_test1_generated.h",
         "namespace_test/namespace_test2_generated.h",
         "native_inline_table_test_generated.h",
@@ -136,6 +137,7 @@ cc_test(
     deps = [
         ":alignment_test_cc_fbs",
         ":arrays_test_cc_fbs",
+        ":cross_namespace_pack_test_cc_fbs",
         ":default_vectors_strings_test_cc_fbs",
         ":monster_extra_cc_fbs",
         ":monster_test_cc_fbs",
@@ -261,6 +263,17 @@ flatbuffer_cc_library(
     ],
 )
 
+flatbuffer_cc_library(
+    name = "cross_namespace_pack_test_cc_fbs",
+    srcs = ["cross_namespace_pack_test.fbs"],
+    flatc_args = [
+        "--gen-object-api",
+        "--gen-mutable",
+        "--gen-compare",
+        "--reflect-names",
+    ],
+)
+
 flatbuffer_cc_library(
     name = "native_type_test_cc_fbs",
     srcs = ["native_type_test.fbs"],

tests/FlatBuffers.Test/FlatBuffers.Test.csproj

@@ -106,6 +106,9 @@
     <Compile Include="..\MyGame\Example\NestedStruct.cs">
       <Link>MyGame\Example\NestedStruct.cs</Link>
     </Compile>
+    <Compile Include="..\MyGame\Example\LargeArrayStruct.cs">
+      <Link>MyGame\Example\LargeArrayStruct.cs</Link>
+    </Compile>
     <Compile Include="..\MyGame\Example\LongEnum.cs">
       <Link>MyGame\Example\LongEnum.cs</Link>
     </Compile>

tests/FlatBuffers.Test/FlatBuffersExampleTests.cs

@@ -1,4 +1,4 @@
-/*
+/*
  * Copyright 2014 Google Inc. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -90,6 +90,9 @@ namespace Google.FlatBuffers.Test
             fbb.AddOffset(test1.Value);
             var testArrayOfString = fbb.EndVector();
 
+            var longsVector = Monster.CreateVectorOfLongsVector(fbb, new long[] { 1, 100, 10000, 1000000, 100000000 });
+            var doublesVector = Monster.CreateVectorOfDoublesVector(fbb, new double[] { -1.7976931348623157e+308, 0, 1.7976931348623157e+308 });
+
             Monster.StartMonster(fbb);
             Monster.AddPos(fbb, Vec3.CreateVec3(fbb, 1.0f, 2.0f, 3.0f, 3.0,
                                                      Color.Green, (short)5, (sbyte)6));
@@ -102,6 +105,8 @@ namespace Google.FlatBuffers.Test
             Monster.AddTestarrayofstring(fbb, testArrayOfString);
             Monster.AddTestbool(fbb, true);
             Monster.AddTestarrayoftables(fbb, sortMons);
+            Monster.AddVectorOfLongs(fbb, longsVector);
+            Monster.AddVectorOfDoubles(fbb, doublesVector);
             var mon = Monster.EndMonster(fbb);
 
             if (sizePrefix)
@@ -285,6 +290,13 @@ namespace Google.FlatBuffers.Test
                 Assert.IsTrue(monster.GetTestarrayofboolsBytes().HasValue);
             }
             #endif
+
+            var longArray = monster.GetVectorOfLongsArray();
+            Assert.AreEqual(5, longArray.Length);
+            Assert.AreEqual(100, longArray[1]);
+
+            var doublesArray = monster.GetVectorOfDoublesArray();
+            Assert.AreEqual(3, doublesArray.Length);
         }
 
         [FlatBuffersTestMethod]

tests/FlatBuffers.Test/FlatBuffersFixedLengthArrayTests.cs

@@ -0,0 +1,249 @@
+/*
+ * Copyright 2025 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System;
+using System.Linq;
+using MyGame.Example;
+
+namespace Google.FlatBuffers.Test
+{
+    [FlatBuffersTestClass]
+    public class FlatBuffersFixedLengthArrayTests
+    {
+        [FlatBuffersTestMethod]
+        public void FixedLengthArray_LengthConstantsMatchSchema_ReturnTrue()
+        {
+            const int nestedALength = NestedStruct.ALength;
+            const int nestedCLength = NestedStruct.CLength;
+            const int nestedDLength = NestedStruct.DLength;
+            const int arrayBLength = ArrayStruct.BLength;
+            const int arrayFLength = ArrayStruct.FLength;
+
+            Assert.AreEqual(2, nestedALength);
+            Assert.AreEqual(2, nestedCLength);
+            Assert.AreEqual(2, nestedDLength);
+            Assert.AreEqual(15, arrayBLength);
+            Assert.AreEqual(2, arrayFLength);
+        }
+
+#if ENABLE_SPAN_T
+        [FlatBuffersTestMethod]
+        public void FixedLengthArray_GetBytesSpanLengthIsCorrect_ReturnTrue()
+        {
+            var builder = new FlatBufferBuilder(1024);
+            var ints = new int[] { 1, 2 };
+            var enumB = TestEnum.A;
+            var enums = new TestEnum[] { TestEnum.B, TestEnum.C };
+            var longs = new long[] { 10L, 20L };
+            
+            var structOffset = NestedStruct.CreateNestedStruct(builder, ints, enumB, enums, longs);
+            builder.Finish(structOffset.Value);
+            
+            var bb = builder.DataBuffer;
+            var nestedStruct = new NestedStruct();
+            nestedStruct.__assign(bb.Length - builder.Offset, bb);
+
+            Span<int> intSpan = nestedStruct.GetABytes();
+            Span<TestEnum> enumSpan = nestedStruct.GetCBytes();
+            Span<long> longSpan = nestedStruct.GetDBytes();
+
+            Assert.AreEqual(intSpan.Length, NestedStruct.ALength);
+            Assert.AreEqual(enumSpan.Length, NestedStruct.CLength);
+            Assert.AreEqual(longSpan.Length, NestedStruct.DLength);          
+        }
+#endif
+
+#if !ENABLE_SPAN_T
+        [FlatBuffersTestMethod]
+        public void FixedLengthArray_GetBytesArraySegmentLengthIsCorrect_ReturnTrue()
+        {
+            var builder = new FlatBufferBuilder(1024);
+            var ints = new int[] { 1, 2 };
+            var enumB = TestEnum.A;
+            var enums = new TestEnum[] { TestEnum.B, TestEnum.C };
+            var longs = new long[] { 10L, 20L };
+
+            var structOffset = NestedStruct.CreateNestedStruct(builder, ints, enumB, enums, longs);
+            builder.Finish(structOffset.Value);
+
+            var buffer = builder.DataBuffer;
+            var nestedStruct = new NestedStruct();
+            nestedStruct.__assign(buffer.Length - builder.Offset, buffer);
+
+            Assert.IsTrue(nestedStruct.GetABytes().HasValue);
+            Assert.IsTrue(nestedStruct.GetCBytes().HasValue);
+            Assert.IsTrue(nestedStruct.GetDBytes().HasValue);
+
+            ArraySegment<byte> intSegment = nestedStruct.GetABytes().Value;
+            ArraySegment<byte> enumSegment = nestedStruct.GetCBytes().Value;
+            ArraySegment<byte> longSegment = nestedStruct.GetDBytes().Value;
+
+            Assert.AreEqual(intSegment.Count, NestedStruct.ALength * sizeof(int));
+            Assert.AreEqual(enumSegment.Count, NestedStruct.CLength * sizeof(sbyte));
+            Assert.AreEqual(longSegment.Count, NestedStruct.DLength * sizeof(long));
+        }
+#endif
+
+#if ENABLE_SPAN_T
+        [FlatBuffersTestMethod]
+        public void FixedLengthArray_GetBytesSpanEquality_ReturnTrue()
+        {
+            var builder = new FlatBufferBuilder(1024);
+
+            var floatA = 3.14f;
+            var intArray = Enumerable.Range(1, 15).ToArray();
+            var byteC = (sbyte)42;
+            var intE = 999;
+            var longArray = new long[] { 5000L, 6000L };
+
+            var nestedInts = new int[2, 2] { { 10, 20 }, { 30, 40 } };
+            var nestedEnumB = new TestEnum[] { TestEnum.A, TestEnum.B };
+            var nestedEnums = new TestEnum[2, 2] { { TestEnum.A, TestEnum.B }, { TestEnum.C, TestEnum.A } };
+            var nestedLongs = new long[2, 2] { { 100L, 200L }, { 300L, 400L } };
+
+            var structOffset = ArrayStruct.CreateArrayStruct(builder, floatA, intArray, byteC,
+                nestedInts, nestedEnumB, nestedEnums, nestedLongs, intE, longArray);
+
+            ArrayTable.StartArrayTable(builder);
+            ArrayTable.AddA(builder, structOffset);
+            var rootTable = ArrayTable.EndArrayTable(builder);
+            builder.Finish(rootTable.Value);
+
+            var finishedBytes = builder.SizedByteArray();
+            ByteBuffer bb = new ByteBuffer(finishedBytes);
+            ArrayTable arrayTable = ArrayTable.GetRootAsArrayTable(bb);
+            ArrayStruct arrayStruct = arrayTable.A.Value;
+
+            Assert.AreEqual(byteC, arrayStruct.C);
+            Assert.AreEqual(intE, arrayStruct.E);
+
+            Assert.IsTrue(arrayStruct.GetBBytes().SequenceEqual(intArray));
+            Assert.IsTrue(arrayStruct.GetFBytes().SequenceEqual(longArray));
+            
+            // Test nested struct arrays
+            for (int i = 0; i < 2; i++)
+            {
+                var nestedStruct = arrayStruct.D(i);
+                
+                var nestedIntSpan = nestedStruct.GetABytes();
+                var expectedNestedInts = new int[] { nestedInts[i, 0], nestedInts[i, 1] };
+                Assert.IsTrue(nestedIntSpan.SequenceEqual(expectedNestedInts));
+                
+                Assert.AreEqual(nestedEnumB[i], nestedStruct.B);
+                
+                var nestedEnumSpan = nestedStruct.GetCBytes();
+                var expectedNestedEnums = new TestEnum[] { nestedEnums[i, 0], nestedEnums[i, 1] };
+                Assert.IsTrue(nestedEnumSpan.SequenceEqual(expectedNestedEnums));
+                
+                var nestedLongSpan = nestedStruct.GetDBytes();
+                var expectedNestedLongs = new long[] { nestedLongs[i, 0], nestedLongs[i, 1] };
+                Assert.IsTrue(nestedLongSpan.SequenceEqual(expectedNestedLongs));
+            }
+        }
+#endif  
+
+#if !ENABLE_SPAN_T
+        [FlatBuffersTestMethod] 
+        public void FixedLengthArray_GetBytesArraySegmentEquality_ReturnTrue()
+        {
+            var builder = new FlatBufferBuilder(1024);
+            
+            var floatA = 3.14f;
+            var intArray = Enumerable.Range(1, 15).ToArray();
+            var byteC = (sbyte)42;
+            var intE = 999;
+            var longArray = new long[] { 5000L, 6000L };
+            
+            var nestedInts = new int[2, 2] { { 10, 20 }, { 30, 40 } };
+            var nestedEnumB = new TestEnum[] { TestEnum.A, TestEnum.B };
+            var nestedEnums = new TestEnum[2, 2] { { TestEnum.A, TestEnum.B }, { TestEnum.C, TestEnum.A } };
+            var nestedLongs = new long[2, 2] { { 100L, 200L }, { 300L, 400L } };
+            
+            var structOffset = ArrayStruct.CreateArrayStruct(builder, floatA, intArray, byteC, 
+                nestedInts, nestedEnumB, nestedEnums, nestedLongs, intE, longArray);
+
+            ArrayTable.StartArrayTable(builder);
+            ArrayTable.AddA(builder, structOffset);
+            var rootTable = ArrayTable.EndArrayTable(builder);
+            builder.Finish(rootTable.Value);
+
+            var finishedBytes = builder.SizedByteArray();
+            ByteBuffer bb = new ByteBuffer(finishedBytes);
+            ArrayTable arrayTable = ArrayTable.GetRootAsArrayTable(bb);
+            ArrayStruct arrayStruct = arrayTable.A.Value;
+
+            // Test that we can read basic scalars correctly
+            Assert.AreEqual(byteC, arrayStruct.C);
+            Assert.AreEqual(intE, arrayStruct.E);
+            
+            Assert.IsTrue(arrayStruct.GetBBytes().HasValue);
+            var intSegment = arrayStruct.GetBBytes().Value;
+            for (int i = 0, offset = 0; i < intArray.Length; i++, offset += sizeof(int))
+            {
+                var segmentValue = BitConverter.ToInt32(intSegment.Array,
+                    intSegment.Offset + offset);
+                Assert.AreEqual(intArray[i], segmentValue);
+            }
+            
+            Assert.IsTrue(arrayStruct.GetFBytes().HasValue);
+            var longSegment = arrayStruct.GetFBytes().Value;
+            for (int i = 0, offset = 0; i < longArray.Length; i++, offset += sizeof(long))
+            {
+                var segmentValue = BitConverter.ToInt64(longSegment.Array,
+                    longSegment.Offset + offset);
+                Assert.AreEqual(longArray[i], segmentValue);
+            }
+            
+            // Test nested struct arrays
+            for (int i = 0; i < 2; i++)
+            {
+                var nestedStruct = arrayStruct.D(i);
+                
+                Assert.IsTrue(nestedStruct.GetABytes().HasValue);
+                var nestedIntSegment = nestedStruct.GetABytes().Value;
+                var expectedNestedInts = new int[] { nestedInts[i, 0], nestedInts[i, 1] };
+                for (int ii = 0, offset = 0; ii < NestedStruct.ALength; ii++, offset += sizeof(int))
+                {
+                    var segmentValue = BitConverter.ToInt32(nestedIntSegment.Array,
+                        nestedIntSegment.Offset + offset);
+                    Assert.AreEqual(expectedNestedInts[ii], segmentValue);
+                }
+
+                Assert.AreEqual(nestedEnumB[i], nestedStruct.B);
+                
+                Assert.IsTrue(nestedStruct.GetCBytes().HasValue);
+                var nestedEnumSegment = nestedStruct.GetCBytes().Value;
+                var expectedNestedEnums = new TestEnum[] { nestedEnums[i, 0], nestedEnums[i, 1] };
+                for (int ii = 0, offset = 0; ii < NestedStruct.CLength; ii++, offset += sizeof(sbyte))
+                {
+                    var segmentValue = (TestEnum)nestedEnumSegment.Array[nestedEnumSegment.Offset + offset];
+                    Assert.AreEqual(expectedNestedEnums[ii], segmentValue);
+                }
+                
+                Assert.IsTrue(nestedStruct.GetDBytes().HasValue);
+                var nestedLongSegment = nestedStruct.GetDBytes().Value;
+                var expectedNestedLongs = new long[] { nestedLongs[i, 0], nestedLongs[i, 1] };
+                for (int ii = 0, offset = 0; ii < NestedStruct.DLength; ii++, offset += sizeof(long))
+                {
+                    var segmentValue = BitConverter.ToInt64(nestedLongSegment.Array,
+                        nestedLongSegment.Offset + offset);
+                    Assert.AreEqual(expectedNestedLongs[ii], segmentValue);
+                }
+            }
+        }
+#endif
+    }
+}

tests/MyGame/Example/ArrayStruct.cs

@@ -19,6 +19,12 @@ public struct ArrayStruct : IFlatbufferObject
   public float A { get { return __p.bb.GetFloat(__p.bb_pos + 0); } }
   public void MutateA(float a) { __p.bb.PutFloat(__p.bb_pos + 0, a); }
   public int B(int j) { return __p.bb.GetInt(__p.bb_pos + 4 + j * 4); }
+  public const int BLength = 15;
+#if ENABLE_SPAN_T
+  public Span<int> GetBBytes() { return System.Runtime.InteropServices.MemoryMarshal.Cast<byte, int>(__p.bb.ToSpan(__p.bb_pos + 4, 60)); }
+#else
+  public ArraySegment<byte>? GetBBytes() { return __p.bb.ToArraySegment(__p.bb_pos + 4, 60);}
+#endif
   public void MutateB(int j, int b) { __p.bb.PutInt(__p.bb_pos + 4 + j * 4, b); }
   public sbyte C { get { return __p.bb.GetSbyte(__p.bb_pos + 64); } }
   public void MutateC(sbyte c) { __p.bb.PutSbyte(__p.bb_pos + 64, c); }
@@ -26,6 +32,12 @@ public struct ArrayStruct : IFlatbufferObject
   public int E { get { return __p.bb.GetInt(__p.bb_pos + 136); } }
   public void MutateE(int e) { __p.bb.PutInt(__p.bb_pos + 136, e); }
   public long F(int j) { return __p.bb.GetLong(__p.bb_pos + 144 + j * 8); }
+  public const int FLength = 2;
+#if ENABLE_SPAN_T
+  public Span<long> GetFBytes() { return System.Runtime.InteropServices.MemoryMarshal.Cast<byte, long>(__p.bb.ToSpan(__p.bb_pos + 144, 16)); }
+#else
+  public ArraySegment<byte>? GetFBytes() { return __p.bb.ToArraySegment(__p.bb_pos + 144, 16);}
+#endif
   public void MutateF(int j, long f) { __p.bb.PutLong(__p.bb_pos + 144 + j * 8, f); }
 
   public static Offset<MyGame.Example.ArrayStruct> CreateArrayStruct(FlatBufferBuilder builder, float A, int[] B, sbyte C, int[,] d_A, MyGame.Example.TestEnum[] d_B, MyGame.Example.TestEnum[,] d_C, long[,] d_D, int E, long[] F) {

tests/MyGame/Example/LargeArrayStruct.cs

@@ -0,0 +1,150 @@
+// <auto-generated>
+//  automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+namespace MyGame.Example
+{
+
+using global::System;
+using global::System.Collections.Generic;
+using global::Google.FlatBuffers;
+
+public struct LargeArrayStruct : IFlatbufferObject
+{
+  private Struct __p;
+  public ByteBuffer ByteBuffer { get { return __p.bb; } }
+  public void __init(int _i, ByteBuffer _bb) { __p = new Struct(_i, _bb); }
+  public LargeArrayStruct __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public byte D(int j) { return __p.bb.Get(__p.bb_pos + 0 + j * 1); }
+  public const int DLength = 64;
+#if ENABLE_SPAN_T
+  public Span<byte> GetDBytes() { return __p.bb.ToSpan(__p.bb_pos + 0, 64); }
+#else
+  public ArraySegment<byte>? GetDBytes() { return __p.bb.ToArraySegment(__p.bb_pos + 0, 64);}
+#endif
+  public void MutateD(int j, byte d) { __p.bb.Put(__p.bb_pos + 0 + j * 1, d); }
+  public float E(int j) { return __p.bb.GetFloat(__p.bb_pos + 64 + j * 4); }
+  public const int ELength = 64;
+#if ENABLE_SPAN_T
+  public Span<float> GetEBytes() { return System.Runtime.InteropServices.MemoryMarshal.Cast<byte, float>(__p.bb.ToSpan(__p.bb_pos + 64, 256)); }
+#else
+  public ArraySegment<byte>? GetEBytes() { return __p.bb.ToArraySegment(__p.bb_pos + 64, 256);}
+#endif
+  public void MutateE(int j, float e) { __p.bb.PutFloat(__p.bb_pos + 64 + j * 4, e); }
+  public bool F(int j) { return 0!=__p.bb.Get(__p.bb_pos + 320 + j * 1); }
+  public const int FLength = 64;
+#if ENABLE_SPAN_T
+  public Span<bool> GetFBytes() { return System.Runtime.InteropServices.MemoryMarshal.Cast<byte, bool>(__p.bb.ToSpan(__p.bb_pos + 320, 64)); }
+#else
+  public ArraySegment<byte>? GetFBytes() { return __p.bb.ToArraySegment(__p.bb_pos + 320, 64);}
+#endif
+  public void MutateF(int j, bool f) { __p.bb.Put(__p.bb_pos + 320 + j * 1, (byte)(f ? 1 : 0)); }
+  public MyGame.Example.NestedStruct G(int j) { return (new MyGame.Example.NestedStruct()).__assign(__p.bb_pos + 384 + j * 32, __p.bb); }
+  public MyGame.Example.TestEnum H(int j) { return (MyGame.Example.TestEnum)__p.bb.GetSbyte(__p.bb_pos + 2432 + j * 1); }
+  public const int HLength = 64;
+#if ENABLE_SPAN_T
+  public Span<MyGame.Example.TestEnum> GetHBytes() { return System.Runtime.InteropServices.MemoryMarshal.Cast<byte, MyGame.Example.TestEnum>(__p.bb.ToSpan(__p.bb_pos + 2432, 64)); }
+#else
+  public ArraySegment<byte>? GetHBytes() { return __p.bb.ToArraySegment(__p.bb_pos + 2432, 64);}
+#endif
+  public void MutateH(int j, MyGame.Example.TestEnum h) { __p.bb.PutSbyte(__p.bb_pos + 2432 + j * 1, (sbyte)h); }
+
+  public static Offset<MyGame.Example.LargeArrayStruct> CreateLargeArrayStruct(FlatBufferBuilder builder, byte[] D, float[] E, bool[] F, int[,] g_A, MyGame.Example.TestEnum[] g_B, MyGame.Example.TestEnum[,] g_C, long[,] g_D, MyGame.Example.TestEnum[] H) {
+    builder.Prep(8, 2496);
+    for (int _idx0 = 64; _idx0 > 0; _idx0--) {
+      builder.PutSbyte((sbyte)H[_idx0-1]);
+    }
+    for (int _idx0 = 64; _idx0 > 0; _idx0--) {
+      builder.Prep(8, 32);
+      for (int _idx1 = 2; _idx1 > 0; _idx1--) {
+        builder.PutLong(g_D[_idx0-1,_idx1-1]);
+      }
+      builder.Pad(5);
+      for (int _idx1 = 2; _idx1 > 0; _idx1--) {
+        builder.PutSbyte((sbyte)g_C[_idx0-1,_idx1-1]);
+      }
+      builder.PutSbyte((sbyte)g_B[_idx0-1]);
+      for (int _idx1 = 2; _idx1 > 0; _idx1--) {
+        builder.PutInt(g_A[_idx0-1,_idx1-1]);
+      }
+    }
+    for (int _idx0 = 64; _idx0 > 0; _idx0--) {
+      builder.PutBool(F[_idx0-1]);
+    }
+    for (int _idx0 = 64; _idx0 > 0; _idx0--) {
+      builder.PutFloat(E[_idx0-1]);
+    }
+    for (int _idx0 = 64; _idx0 > 0; _idx0--) {
+      builder.PutByte(D[_idx0-1]);
+    }
+    return new Offset<MyGame.Example.LargeArrayStruct>(builder.Offset);
+  }
+  public LargeArrayStructT UnPack() {
+    var _o = new LargeArrayStructT();
+    this.UnPackTo(_o);
+    return _o;
+  }
+  public void UnPackTo(LargeArrayStructT _o) {
+    _o.D = new byte[64];
+    for (var _j = 0; _j < 64; ++_j) { _o.D[_j] = this.D(_j); }
+    _o.E = new float[64];
+    for (var _j = 0; _j < 64; ++_j) { _o.E[_j] = this.E(_j); }
+    _o.F = new bool[64];
+    for (var _j = 0; _j < 64; ++_j) { _o.F[_j] = this.F(_j); }
+    _o.G = new MyGame.Example.NestedStructT[64];
+    for (var _j = 0; _j < 64; ++_j) { _o.G[_j] = this.G(_j).UnPack(); }
+    _o.H = new MyGame.Example.TestEnum[64];
+    for (var _j = 0; _j < 64; ++_j) { _o.H[_j] = this.H(_j); }
+  }
+  public static Offset<MyGame.Example.LargeArrayStruct> Pack(FlatBufferBuilder builder, LargeArrayStructT _o) {
+    if (_o == null) return default(Offset<MyGame.Example.LargeArrayStruct>);
+    var _d = _o.D;
+    var _e = _o.E;
+    var _f = _o.F;
+    var _g_a = new int[64,2];
+    for (var idx0 = 0; idx0 < 64; ++idx0) {for (var idx1 = 0; idx1 < 2; ++idx1) {_g_a[idx0,idx1] = _o.G[idx0].A[idx1];}}
+    var _g_b = new MyGame.Example.TestEnum[64];
+    for (var idx0 = 0; idx0 < 64; ++idx0) {_g_b[idx0] = _o.G[idx0].B;}
+    var _g_c = new MyGame.Example.TestEnum[64,2];
+    for (var idx0 = 0; idx0 < 64; ++idx0) {for (var idx1 = 0; idx1 < 2; ++idx1) {_g_c[idx0,idx1] = _o.G[idx0].C[idx1];}}
+    var _g_d = new long[64,2];
+    for (var idx0 = 0; idx0 < 64; ++idx0) {for (var idx1 = 0; idx1 < 2; ++idx1) {_g_d[idx0,idx1] = _o.G[idx0].D[idx1];}}
+    var _h = _o.H;
+    return CreateLargeArrayStruct(
+      builder,
+      _d,
+      _e,
+      _f,
+      _g_a,
+      _g_b,
+      _g_c,
+      _g_d,
+      _h);
+  }
+}
+
+public class LargeArrayStructT
+{
+  [Newtonsoft.Json.JsonProperty("d")]
+  public byte[] D { get; set; }
+  [Newtonsoft.Json.JsonProperty("e")]
+  public float[] E { get; set; }
+  [Newtonsoft.Json.JsonProperty("f")]
+  public bool[] F { get; set; }
+  [Newtonsoft.Json.JsonProperty("g")]
+  public MyGame.Example.NestedStructT[] G { get; set; }
+  [Newtonsoft.Json.JsonProperty("h")]
+  public MyGame.Example.TestEnum[] H { get; set; }
+
+  public LargeArrayStructT() {
+    this.D = new byte[64];
+    this.E = new float[64];
+    this.F = new bool[64];
+    this.G = new MyGame.Example.NestedStructT[64];
+    this.H = new MyGame.Example.TestEnum[64];
+  }
+}
+
+
+}

tests/MyGame/Example/LargeArrayStruct.java

@@ -0,0 +1,117 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package MyGame.Example;
+
+import com.google.flatbuffers.BaseVector;
+import com.google.flatbuffers.BooleanVector;
+import com.google.flatbuffers.ByteVector;
+import com.google.flatbuffers.Constants;
+import com.google.flatbuffers.DoubleVector;
+import com.google.flatbuffers.FlatBufferBuilder;
+import com.google.flatbuffers.FloatVector;
+import com.google.flatbuffers.IntVector;
+import com.google.flatbuffers.LongVector;
+import com.google.flatbuffers.ShortVector;
+import com.google.flatbuffers.StringVector;
+import com.google.flatbuffers.Struct;
+import com.google.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+@SuppressWarnings("unused")
+public final class LargeArrayStruct extends Struct {
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public LargeArrayStruct __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public int d(int j) { return bb.get(bb_pos + 0 + j * 1); }
+  public void mutateD(int j, int d) { bb.put(bb_pos + 0 + j * 1, (byte) d); }
+  public float e(int j) { return bb.getFloat(bb_pos + 64 + j * 4); }
+  public void mutateE(int j, float e) { bb.putFloat(bb_pos + 64 + j * 4, e); }
+  public boolean f(int j) { return 0!=bb.get(bb_pos + 320 + j * 1); }
+  public void mutateF(int j, boolean f) { bb.put(bb_pos + 320 + j * 1, (byte)(f ? 1 : 0)); }
+  public MyGame.Example.NestedStruct g(int j) { return g(new MyGame.Example.NestedStruct(), j); }
+  public MyGame.Example.NestedStruct g(MyGame.Example.NestedStruct obj, int j) { return obj.__assign(bb_pos + 384 + j * 32, bb); }
+  public byte h(int j) { return bb.get(bb_pos + 2432 + j * 1); }
+  public void mutateH(int j, byte h) { bb.put(bb_pos + 2432 + j * 1, h); }
+
+  public static int createLargeArrayStruct(FlatBufferBuilder builder, int[] d, float[] e, boolean[] f, int[][] g_a, byte[] g_b, byte[][] g_c, long[][] g_d, byte[] h) {
+    builder.prep(8, 2496);
+    for (int _idx0 = 64; _idx0 > 0; _idx0--) {
+      builder.putByte(h[_idx0-1]);
+    }
+    for (int _idx0 = 64; _idx0 > 0; _idx0--) {
+      builder.prep(8, 32);
+      for (int _idx1 = 2; _idx1 > 0; _idx1--) {
+        builder.putLong(g_d[_idx0-1][_idx1-1]);
+      }
+      builder.pad(5);
+      for (int _idx1 = 2; _idx1 > 0; _idx1--) {
+        builder.putByte(g_c[_idx0-1][_idx1-1]);
+      }
+      builder.putByte(g_b[_idx0-1]);
+      for (int _idx1 = 2; _idx1 > 0; _idx1--) {
+        builder.putInt(g_a[_idx0-1][_idx1-1]);
+      }
+    }
+    for (int _idx0 = 64; _idx0 > 0; _idx0--) {
+      builder.putBoolean(f[_idx0-1]);
+    }
+    for (int _idx0 = 64; _idx0 > 0; _idx0--) {
+      builder.putFloat(e[_idx0-1]);
+    }
+    for (int _idx0 = 64; _idx0 > 0; _idx0--) {
+      builder.putByte((byte) d[_idx0-1]);
+    }
+    return builder.offset();
+  }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public LargeArrayStruct get(int j) { return get(new LargeArrayStruct(), j); }
+    public LargeArrayStruct get(LargeArrayStruct obj, int j) {  return obj.__assign(__element(j), bb); }
+  }
+  public LargeArrayStructT unpack() {
+    LargeArrayStructT _o = new LargeArrayStructT();
+    unpackTo(_o);
+    return _o;
+  }
+  public void unpackTo(LargeArrayStructT _o) {
+    int[] _oD = _o.getD();
+    for (int _j = 0; _j < 64; ++_j) { _oD[_j] = d(_j); }
+    float[] _oE = _o.getE();
+    for (int _j = 0; _j < 64; ++_j) { _oE[_j] = e(_j); }
+    boolean[] _oF = _o.getF();
+    for (int _j = 0; _j < 64; ++_j) { _oF[_j] = f(_j); }
+    MyGame.Example.NestedStructT[] _oG = _o.getG();
+    for (int _j = 0; _j < 64; ++_j) { _oG[_j] = g(_j).unpack(); }
+    byte[] _oH = _o.getH();
+    for (int _j = 0; _j < 64; ++_j) { _oH[_j] = h(_j); }
+  }
+  public static int pack(FlatBufferBuilder builder, LargeArrayStructT _o) {
+    if (_o == null) return 0;
+    int[] _d = _o.getD();
+    float[] _e = _o.getE();
+    boolean[] _f = _o.getF();
+    int[][] _g_a = new int[64][2];
+    for (int idx0 = 0; idx0 < 64; ++idx0) {for (int idx1 = 0; idx1 < 2; ++idx1) {_g_a[idx0][idx1] = _o.getG()[idx0].getA()[idx1];}}
+    byte[] _g_b = new byte[64];
+    for (int idx0 = 0; idx0 < 64; ++idx0) {_g_b[idx0] = _o.getG()[idx0].getB();}
+    byte[][] _g_c = new byte[64][2];
+    for (int idx0 = 0; idx0 < 64; ++idx0) {for (int idx1 = 0; idx1 < 2; ++idx1) {_g_c[idx0][idx1] = _o.getG()[idx0].getC()[idx1];}}
+    long[][] _g_d = new long[64][2];
+    for (int idx0 = 0; idx0 < 64; ++idx0) {for (int idx1 = 0; idx1 < 2; ++idx1) {_g_d[idx0][idx1] = _o.getG()[idx0].getD()[idx1];}}
+    byte[] _h = _o.getH();
+    return createLargeArrayStruct(
+      builder,
+      _d,
+      _e,
+      _f,
+      _g_a,
+      _g_b,
+      _g_c,
+      _g_d,
+      _h);
+  }
+}
+

tests/MyGame/Example/LargeArrayStruct.py

@@ -0,0 +1,226 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: Example
+
+import flatbuffers
+from flatbuffers.compat import import_numpy
+from typing import Any
+from MyGame.Example.NestedStruct import NestedStruct
+np = import_numpy()
+
+class LargeArrayStruct(object):
+    __slots__ = ['_tab']
+
+    @classmethod
+    def SizeOf(cls) -> int:
+        return 2496
+
+    # LargeArrayStruct
+    def Init(self, buf: bytes, pos: int):
+        self._tab = flatbuffers.table.Table(buf, pos)
+
+    # LargeArrayStruct
+    def D(self, j = None):
+        if j is None:
+            return [self._tab.Get(flatbuffers.number_types.Uint8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0 + i * 1)) for i in range(self.DLength())]
+        elif j >= 0 and j < self.DLength():
+            return self._tab.Get(flatbuffers.number_types.Uint8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(0 + j * 1))
+        else:
+            return None
+
+    # LargeArrayStruct
+    def DAsNumpy(self):
+        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Uint8Flags, self._tab.Pos + 0, self.DLength())
+
+    # LargeArrayStruct
+    def DLength(self) -> int:
+        return 64
+
+    # LargeArrayStruct
+    def DIsNone(self) -> bool:
+        return False
+
+    # LargeArrayStruct
+    def E(self, j = None):
+        if j is None:
+            return [self._tab.Get(flatbuffers.number_types.Float32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(64 + i * 4)) for i in range(self.ELength())]
+        elif j >= 0 and j < self.ELength():
+            return self._tab.Get(flatbuffers.number_types.Float32Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(64 + j * 4))
+        else:
+            return None
+
+    # LargeArrayStruct
+    def EAsNumpy(self):
+        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Float32Flags, self._tab.Pos + 64, self.ELength())
+
+    # LargeArrayStruct
+    def ELength(self) -> int:
+        return 64
+
+    # LargeArrayStruct
+    def EIsNone(self) -> bool:
+        return False
+
+    # LargeArrayStruct
+    def F(self, j = None):
+        if j is None:
+            return [self._tab.Get(flatbuffers.number_types.BoolFlags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(320 + i * 1)) for i in range(self.FLength())]
+        elif j >= 0 and j < self.FLength():
+            return self._tab.Get(flatbuffers.number_types.BoolFlags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(320 + j * 1))
+        else:
+            return None
+
+    # LargeArrayStruct
+    def FAsNumpy(self):
+        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.BoolFlags, self._tab.Pos + 320, self.FLength())
+
+    # LargeArrayStruct
+    def FLength(self) -> int:
+        return 64
+
+    # LargeArrayStruct
+    def FIsNone(self) -> bool:
+        return False
+
+    # LargeArrayStruct
+    def G(self, i: int) -> NestedStruct:
+        obj = NestedStruct()
+        obj.Init(self._tab.Bytes, self._tab.Pos + 384 + i * 32)
+        return obj
+
+    # LargeArrayStruct
+    def GLength(self) -> int:
+        return 64
+
+    # LargeArrayStruct
+    def GIsNone(self) -> bool:
+        return False
+
+    # LargeArrayStruct
+    def H(self, j = None):
+        if j is None:
+            return [self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(2432 + i * 1)) for i in range(self.HLength())]
+        elif j >= 0 and j < self.HLength():
+            return self._tab.Get(flatbuffers.number_types.Int8Flags, self._tab.Pos + flatbuffers.number_types.UOffsetTFlags.py_type(2432 + j * 1))
+        else:
+            return None
+
+    # LargeArrayStruct
+    def HAsNumpy(self):
+        return self._tab.GetArrayAsNumpy(flatbuffers.number_types.Int8Flags, self._tab.Pos + 2432, self.HLength())
+
+    # LargeArrayStruct
+    def HLength(self) -> int:
+        return 64
+
+    # LargeArrayStruct
+    def HIsNone(self) -> bool:
+        return False
+
+
+def CreateLargeArrayStruct(builder, d, e, f, g_a, g_b, g_c, g_d, h):
+    builder.Prep(8, 2496)
+    for _idx0 in range(64 , 0, -1):
+        builder.PrependInt8(h[_idx0-1])
+    for _idx0 in range(64 , 0, -1):
+        builder.Prep(8, 32)
+        for _idx1 in range(2 , 0, -1):
+            builder.PrependInt64(g_d[_idx0-1][_idx1-1])
+        builder.Pad(5)
+        for _idx1 in range(2 , 0, -1):
+            builder.PrependInt8(g_c[_idx0-1][_idx1-1])
+        builder.PrependInt8(g_b[_idx0-1])
+        for _idx1 in range(2 , 0, -1):
+            builder.PrependInt32(g_a[_idx0-1][_idx1-1])
+    for _idx0 in range(64 , 0, -1):
+        builder.PrependBool(f[_idx0-1])
+    for _idx0 in range(64 , 0, -1):
+        builder.PrependFloat32(e[_idx0-1])
+    for _idx0 in range(64 , 0, -1):
+        builder.PrependUint8(d[_idx0-1])
+    return builder.Offset()
+
+import MyGame.Example.NestedStruct
+try:
+    from typing import List
+except:
+    pass
+
+class LargeArrayStructT(object):
+
+    # LargeArrayStructT
+    def __init__(
+        self,
+        d = None,
+        e = None,
+        f = None,
+        g = None,
+        h = None,
+    ):
+        self.d = d  # type: Optional[List[int]]
+        self.e = e  # type: Optional[List[float]]
+        self.f = f  # type: Optional[List[bool]]
+        self.g = g  # type: Optional[List[MyGame.Example.NestedStruct.NestedStructT]]
+        self.h = h  # type: Optional[List[int]]
+
+    @classmethod
+    def InitFromBuf(cls, buf, pos):
+        largeArrayStruct = LargeArrayStruct()
+        largeArrayStruct.Init(buf, pos)
+        return cls.InitFromObj(largeArrayStruct)
+
+    @classmethod
+    def InitFromPackedBuf(cls, buf, pos=0):
+        n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
+        return cls.InitFromBuf(buf, pos+n)
+
+    @classmethod
+    def InitFromObj(cls, largeArrayStruct):
+        x = LargeArrayStructT()
+        x._UnPack(largeArrayStruct)
+        return x
+
+    # LargeArrayStructT
+    def _UnPack(self, largeArrayStruct):
+        if largeArrayStruct is None:
+            return
+        if not largeArrayStruct.DIsNone():
+            if np is None:
+                self.d = []
+                for i in range(largeArrayStruct.DLength()):
+                    self.d.append(largeArrayStruct.D(i))
+            else:
+                self.d = largeArrayStruct.DAsNumpy()
+        if not largeArrayStruct.EIsNone():
+            if np is None:
+                self.e = []
+                for i in range(largeArrayStruct.ELength()):
+                    self.e.append(largeArrayStruct.E(i))
+            else:
+                self.e = largeArrayStruct.EAsNumpy()
+        if not largeArrayStruct.FIsNone():
+            if np is None:
+                self.f = []
+                for i in range(largeArrayStruct.FLength()):
+                    self.f.append(largeArrayStruct.F(i))
+            else:
+                self.f = largeArrayStruct.FAsNumpy()
+        if not largeArrayStruct.GIsNone():
+            self.g = []
+            for i in range(largeArrayStruct.GLength()):
+                if largeArrayStruct.G(i) is None:
+                    self.g.append(None)
+                else:
+                    nestedStruct_ = MyGame.Example.NestedStruct.NestedStructT.InitFromObj(largeArrayStruct.G(i))
+                    self.g.append(nestedStruct_)
+        if not largeArrayStruct.HIsNone():
+            if np is None:
+                self.h = []
+                for i in range(largeArrayStruct.HLength()):
+                    self.h.append(largeArrayStruct.H(i))
+            else:
+                self.h = largeArrayStruct.HAsNumpy()
+
+    # LargeArrayStructT
+    def Pack(self, builder):
+        return CreateLargeArrayStruct(builder, self.d, self.e, self.f, self.g.a, self.g.b, self.g.c, self.g.d, self.h)

tests/MyGame/Example/LargeArrayStruct.pyi

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import flatbuffers
+import numpy as np
+
+import typing
+from MyGame.Example.NestedStruct import NestedStruct, NestedStructT
+from MyGame.Example.TestEnum import TestEnum
+
+uoffset: typing.TypeAlias = flatbuffers.number_types.UOffsetTFlags.py_type
+
+class LargeArrayStruct(object):
+  @classmethod
+  def SizeOf(cls) -> int: ...
+
+  def Init(self, buf: bytes, pos: int) -> None: ...
+  def D(self, i: int) -> typing.List[int]: ...
+  def DAsNumpy(self) -> np.ndarray: ...
+  def DLength(self) -> int: ...
+  def DIsNone(self) -> bool: ...
+  def E(self, i: int) -> typing.List[float]: ...
+  def EAsNumpy(self) -> np.ndarray: ...
+  def ELength(self) -> int: ...
+  def EIsNone(self) -> bool: ...
+  def F(self, i: int) -> typing.List[bool]: ...
+  def FAsNumpy(self) -> np.ndarray: ...
+  def FLength(self) -> int: ...
+  def FIsNone(self) -> bool: ...
+  def G(self, i: int) -> NestedStruct | None: ...
+  def GLength(self) -> int: ...
+  def GIsNone(self) -> bool: ...
+  def H(self, i: int) -> typing.Literal[TestEnum.A, TestEnum.B, TestEnum.C]: ...
+  def HAsNumpy(self) -> np.ndarray: ...
+  def HLength(self) -> int: ...
+  def HIsNone(self) -> bool: ...
+class LargeArrayStructT(object):
+  d: typing.List[int]
+  e: typing.List[float]
+  f: typing.List[bool]
+  g: typing.List[NestedStructT]
+  h: typing.List[typing.Literal[TestEnum.A, TestEnum.B, TestEnum.C]]
+  def __init__(
+    self,
+    d: typing.List[int] | None = ...,
+    e: typing.List[float] | None = ...,
+    f: typing.List[bool] | None = ...,
+    g: typing.List['NestedStructT'] | None = ...,
+    h: typing.List[typing.Literal[TestEnum.A, TestEnum.B, TestEnum.C]] | None = ...,
+  ) -> None: ...
+  @classmethod
+  def InitFromBuf(cls, buf: bytes, pos: int) -> LargeArrayStructT: ...
+  @classmethod
+  def InitFromPackedBuf(cls, buf: bytes, pos: int = 0) -> LargeArrayStructT: ...
+  @classmethod
+  def InitFromObj(cls, largeArrayStruct: LargeArrayStruct) -> LargeArrayStructT: ...
+  def _UnPack(self, largeArrayStruct: LargeArrayStruct) -> None: ...
+  def Pack(self, builder: flatbuffers.Builder) -> None: ...
+
+def CreateLargeArrayStruct(builder: flatbuffers.Builder, d: int, e: float, f: bool, g_a: int, g_b: typing.Literal[TestEnum.A, TestEnum.B, TestEnum.C], g_c: typing.Literal[TestEnum.A, TestEnum.B, TestEnum.C], g_d: int, h: typing.Literal[TestEnum.A, TestEnum.B, TestEnum.C]) -> uoffset: ...
+

tests/MyGame/Example/LargeArrayStructT.java

@@ -0,0 +1,57 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package MyGame.Example;
+
+import com.google.flatbuffers.BaseVector;
+import com.google.flatbuffers.BooleanVector;
+import com.google.flatbuffers.ByteVector;
+import com.google.flatbuffers.Constants;
+import com.google.flatbuffers.DoubleVector;
+import com.google.flatbuffers.FlatBufferBuilder;
+import com.google.flatbuffers.FloatVector;
+import com.google.flatbuffers.IntVector;
+import com.google.flatbuffers.LongVector;
+import com.google.flatbuffers.ShortVector;
+import com.google.flatbuffers.StringVector;
+import com.google.flatbuffers.Struct;
+import com.google.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+public class LargeArrayStructT {
+  private int[] d;
+  private float[] e;
+  private boolean[] f;
+  private MyGame.Example.NestedStructT[] g;
+  private byte[] h;
+
+  public int[] getD() { return d; }
+
+  public void setD(int[] d) { if (d != null && d.length == 64) this.d = d; }
+
+  public float[] getE() { return e; }
+
+  public void setE(float[] e) { if (e != null && e.length == 64) this.e = e; }
+
+  public boolean[] getF() { return f; }
+
+  public void setF(boolean[] f) { if (f != null && f.length == 64) this.f = f; }
+
+  public MyGame.Example.NestedStructT[] getG() { return g; }
+
+  public void setG(MyGame.Example.NestedStructT[] g) { if (g != null && g.length == 64) this.g = g; }
+
+  public byte[] getH() { return h; }
+
+  public void setH(byte[] h) { if (h != null && h.length == 64) this.h = h; }
+
+
+  public LargeArrayStructT() {
+    this.d = new int[64];
+    this.e = new float[64];
+    this.f = new boolean[64];
+    this.g = new MyGame.Example.NestedStructT[64];
+    this.h = new byte[64];
+  }
+}
+

tests/MyGame/Example/Monster.lua

@@ -28,6 +28,8 @@ function Monster.New()
   return o
 end
 
+local FileIdentifier = "MONS"
+
 function Monster.GetRootAsMonster(buf, offset)
   if type(buf) == "string" then
     buf = flatbuffers.binaryArray.New(buf)
@@ -1099,4 +1101,12 @@ function Monster.End(builder)
   return builder:EndObject()
 end
 
+function Monster.FinishMonsterBuffer(builder, offset)
+  builder:FinishWithIdentifier(offset, FileIdentifier)
+end
+
+function Monster.FinishSizePrefixedMonsterBuffer(builder, offset)
+  builder:FinishSizePrefixedWithIdentifier(offset, FileIdentifier)
+end
+
 return Monster

tests/MyGame/Example/Monster.py

@@ -914,6 +914,16 @@ def MonsterStartInventoryVector(builder, numElems):
 def StartInventoryVector(builder, numElems):
     return MonsterStartInventoryVector(builder, numElems)
 
+def MonsterCreateInventoryVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependUint8(item)
+    return builder.EndVector()
+
+def CreateInventoryVector(builder, data):
+    return MonsterCreateInventoryVector(builder, data)
+
 def MonsterAddColor(builder, color):
     builder.PrependUint8Slot(6, color, 8)
 
@@ -944,6 +954,16 @@ def MonsterStartTest4Vector(builder, numElems):
 def StartTest4Vector(builder, numElems):
     return MonsterStartTest4Vector(builder, numElems)
 
+def MonsterCreateTest4Vector(builder, data):
+    data = list(data)
+    builder.StartVector(4, len(data), 2)
+    for item in reversed(data):
+        item.Pack(builder)
+    return builder.EndVector()
+
+def CreateTest4Vector(builder, data):
+    return MonsterCreateTest4Vector(builder, data)
+
 def MonsterAddTestarrayofstring(builder, testarrayofstring):
     builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofstring), 0)
 
@@ -956,6 +976,12 @@ def MonsterStartTestarrayofstringVector(builder, numElems):
 def StartTestarrayofstringVector(builder, numElems):
     return MonsterStartTestarrayofstringVector(builder, numElems)
 
+def MonsterCreateTestarrayofstringVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateTestarrayofstringVector(builder, data):
+    return MonsterCreateTestarrayofstringVector(builder, data)
+
 def MonsterAddTestarrayoftables(builder, testarrayoftables):
     builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayoftables), 0)
 
@@ -968,6 +994,12 @@ def MonsterStartTestarrayoftablesVector(builder, numElems):
 def StartTestarrayoftablesVector(builder, numElems):
     return MonsterStartTestarrayoftablesVector(builder, numElems)
 
+def MonsterCreateTestarrayoftablesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateTestarrayoftablesVector(builder, data):
+    return MonsterCreateTestarrayoftablesVector(builder, data)
+
 def MonsterAddEnemy(builder, enemy):
     builder.PrependUOffsetTRelativeSlot(12, flatbuffers.number_types.UOffsetTFlags.py_type(enemy), 0)
 
@@ -986,6 +1018,16 @@ def MonsterStartTestnestedflatbufferVector(builder, numElems):
 def StartTestnestedflatbufferVector(builder, numElems):
     return MonsterStartTestnestedflatbufferVector(builder, numElems)
 
+def MonsterCreateTestnestedflatbufferVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependUint8(item)
+    return builder.EndVector()
+
+def CreateTestnestedflatbufferVector(builder, data):
+    return MonsterCreateTestnestedflatbufferVector(builder, data)
+
 def MonsterMakeTestnestedflatbufferVectorFromBytes(builder, bytes):
     builder.StartVector(1, len(bytes), 1)
     builder.head = builder.head - len(bytes)
@@ -1065,6 +1107,16 @@ def MonsterStartTestarrayofboolsVector(builder, numElems):
 def StartTestarrayofboolsVector(builder, numElems):
     return MonsterStartTestarrayofboolsVector(builder, numElems)
 
+def MonsterCreateTestarrayofboolsVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependBool(item)
+    return builder.EndVector()
+
+def CreateTestarrayofboolsVector(builder, data):
+    return MonsterCreateTestarrayofboolsVector(builder, data)
+
 def MonsterAddTestf(builder, testf):
     builder.PrependFloat32Slot(25, testf, 3.14159)
 
@@ -1095,6 +1147,12 @@ def MonsterStartTestarrayofstring2Vector(builder, numElems):
 def StartTestarrayofstring2Vector(builder, numElems):
     return MonsterStartTestarrayofstring2Vector(builder, numElems)
 
+def MonsterCreateTestarrayofstring2Vector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateTestarrayofstring2Vector(builder, data):
+    return MonsterCreateTestarrayofstring2Vector(builder, data)
+
 def MonsterAddTestarrayofsortedstruct(builder, testarrayofsortedstruct):
     builder.PrependUOffsetTRelativeSlot(29, flatbuffers.number_types.UOffsetTFlags.py_type(testarrayofsortedstruct), 0)
 
@@ -1107,6 +1165,16 @@ def MonsterStartTestarrayofsortedstructVector(builder, numElems):
 def StartTestarrayofsortedstructVector(builder, numElems):
     return MonsterStartTestarrayofsortedstructVector(builder, numElems)
 
+def MonsterCreateTestarrayofsortedstructVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 4)
+    for item in reversed(data):
+        item.Pack(builder)
+    return builder.EndVector()
+
+def CreateTestarrayofsortedstructVector(builder, data):
+    return MonsterCreateTestarrayofsortedstructVector(builder, data)
+
 def MonsterAddFlex(builder, flex):
     builder.PrependUOffsetTRelativeSlot(30, flatbuffers.number_types.UOffsetTFlags.py_type(flex), 0)
 
@@ -1119,6 +1187,16 @@ def MonsterStartFlexVector(builder, numElems):
 def StartFlexVector(builder, numElems):
     return MonsterStartFlexVector(builder, numElems)
 
+def MonsterCreateFlexVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependUint8(item)
+    return builder.EndVector()
+
+def CreateFlexVector(builder, data):
+    return MonsterCreateFlexVector(builder, data)
+
 def MonsterAddTest5(builder, test5):
     builder.PrependUOffsetTRelativeSlot(31, flatbuffers.number_types.UOffsetTFlags.py_type(test5), 0)
 
@@ -1131,6 +1209,16 @@ def MonsterStartTest5Vector(builder, numElems):
 def StartTest5Vector(builder, numElems):
     return MonsterStartTest5Vector(builder, numElems)
 
+def MonsterCreateTest5Vector(builder, data):
+    data = list(data)
+    builder.StartVector(4, len(data), 2)
+    for item in reversed(data):
+        item.Pack(builder)
+    return builder.EndVector()
+
+def CreateTest5Vector(builder, data):
+    return MonsterCreateTest5Vector(builder, data)
+
 def MonsterAddVectorOfLongs(builder, vectorOfLongs):
     builder.PrependUOffsetTRelativeSlot(32, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfLongs), 0)
 
@@ -1143,6 +1231,16 @@ def MonsterStartVectorOfLongsVector(builder, numElems):
 def StartVectorOfLongsVector(builder, numElems):
     return MonsterStartVectorOfLongsVector(builder, numElems)
 
+def MonsterCreateVectorOfLongsVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependInt64(item)
+    return builder.EndVector()
+
+def CreateVectorOfLongsVector(builder, data):
+    return MonsterCreateVectorOfLongsVector(builder, data)
+
 def MonsterAddVectorOfDoubles(builder, vectorOfDoubles):
     builder.PrependUOffsetTRelativeSlot(33, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfDoubles), 0)
 
@@ -1155,6 +1253,16 @@ def MonsterStartVectorOfDoublesVector(builder, numElems):
 def StartVectorOfDoublesVector(builder, numElems):
     return MonsterStartVectorOfDoublesVector(builder, numElems)
 
+def MonsterCreateVectorOfDoublesVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependFloat64(item)
+    return builder.EndVector()
+
+def CreateVectorOfDoublesVector(builder, data):
+    return MonsterCreateVectorOfDoublesVector(builder, data)
+
 def MonsterAddParentNamespaceTest(builder, parentNamespaceTest):
     builder.PrependUOffsetTRelativeSlot(34, flatbuffers.number_types.UOffsetTFlags.py_type(parentNamespaceTest), 0)
 
@@ -1173,6 +1281,12 @@ def MonsterStartVectorOfReferrablesVector(builder, numElems):
 def StartVectorOfReferrablesVector(builder, numElems):
     return MonsterStartVectorOfReferrablesVector(builder, numElems)
 
+def MonsterCreateVectorOfReferrablesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateVectorOfReferrablesVector(builder, data):
+    return MonsterCreateVectorOfReferrablesVector(builder, data)
+
 def MonsterAddSingleWeakReference(builder, singleWeakReference):
     builder.PrependUint64Slot(36, singleWeakReference, 0)
 
@@ -1191,6 +1305,16 @@ def MonsterStartVectorOfWeakReferencesVector(builder, numElems):
 def StartVectorOfWeakReferencesVector(builder, numElems):
     return MonsterStartVectorOfWeakReferencesVector(builder, numElems)
 
+def MonsterCreateVectorOfWeakReferencesVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependUint64(item)
+    return builder.EndVector()
+
+def CreateVectorOfWeakReferencesVector(builder, data):
+    return MonsterCreateVectorOfWeakReferencesVector(builder, data)
+
 def MonsterAddVectorOfStrongReferrables(builder, vectorOfStrongReferrables):
     builder.PrependUOffsetTRelativeSlot(38, flatbuffers.number_types.UOffsetTFlags.py_type(vectorOfStrongReferrables), 0)
 
@@ -1203,6 +1327,12 @@ def MonsterStartVectorOfStrongReferrablesVector(builder, numElems):
 def StartVectorOfStrongReferrablesVector(builder, numElems):
     return MonsterStartVectorOfStrongReferrablesVector(builder, numElems)
 
+def MonsterCreateVectorOfStrongReferrablesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateVectorOfStrongReferrablesVector(builder, data):
+    return MonsterCreateVectorOfStrongReferrablesVector(builder, data)
+
 def MonsterAddCoOwningReference(builder, coOwningReference):
     builder.PrependUint64Slot(39, coOwningReference, 0)
 
@@ -1221,6 +1351,16 @@ def MonsterStartVectorOfCoOwningReferencesVector(builder, numElems):
 def StartVectorOfCoOwningReferencesVector(builder, numElems):
     return MonsterStartVectorOfCoOwningReferencesVector(builder, numElems)
 
+def MonsterCreateVectorOfCoOwningReferencesVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependUint64(item)
+    return builder.EndVector()
+
+def CreateVectorOfCoOwningReferencesVector(builder, data):
+    return MonsterCreateVectorOfCoOwningReferencesVector(builder, data)
+
 def MonsterAddNonOwningReference(builder, nonOwningReference):
     builder.PrependUint64Slot(41, nonOwningReference, 0)
 
@@ -1239,6 +1379,16 @@ def MonsterStartVectorOfNonOwningReferencesVector(builder, numElems):
 def StartVectorOfNonOwningReferencesVector(builder, numElems):
     return MonsterStartVectorOfNonOwningReferencesVector(builder, numElems)
 
+def MonsterCreateVectorOfNonOwningReferencesVector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependUint64(item)
+    return builder.EndVector()
+
+def CreateVectorOfNonOwningReferencesVector(builder, data):
+    return MonsterCreateVectorOfNonOwningReferencesVector(builder, data)
+
 def MonsterAddAnyUniqueType(builder, anyUniqueType):
     builder.PrependUint8Slot(43, anyUniqueType, 0)
 
@@ -1275,6 +1425,16 @@ def MonsterStartVectorOfEnumsVector(builder, numElems):
 def StartVectorOfEnumsVector(builder, numElems):
     return MonsterStartVectorOfEnumsVector(builder, numElems)
 
+def MonsterCreateVectorOfEnumsVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependUint8(item)
+    return builder.EndVector()
+
+def CreateVectorOfEnumsVector(builder, data):
+    return MonsterCreateVectorOfEnumsVector(builder, data)
+
 def MonsterAddSignedEnum(builder, signedEnum):
     builder.PrependInt8Slot(48, signedEnum, -1)
 
@@ -1293,6 +1453,16 @@ def MonsterStartTestrequirednestedflatbufferVector(builder, numElems):
 def StartTestrequirednestedflatbufferVector(builder, numElems):
     return MonsterStartTestrequirednestedflatbufferVector(builder, numElems)
 
+def MonsterCreateTestrequirednestedflatbufferVector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependUint8(item)
+    return builder.EndVector()
+
+def CreateTestrequirednestedflatbufferVector(builder, data):
+    return MonsterCreateTestrequirednestedflatbufferVector(builder, data)
+
 def MonsterMakeTestrequirednestedflatbufferVectorFromBytes(builder, bytes):
     builder.StartVector(1, len(bytes), 1)
     builder.head = builder.head - len(bytes)
@@ -1312,6 +1482,12 @@ def MonsterStartScalarKeySortedTablesVector(builder, numElems):
 def StartScalarKeySortedTablesVector(builder, numElems):
     return MonsterStartScalarKeySortedTablesVector(builder, numElems)
 
+def MonsterCreateScalarKeySortedTablesVector(builder, data):
+    return builder.CreateVectorOfTables(data)
+
+def CreateScalarKeySortedTablesVector(builder, data):
+    return MonsterCreateScalarKeySortedTablesVector(builder, data)
+
 def MonsterAddNativeInline(builder, nativeInline):
     builder.PrependStructSlot(51, flatbuffers.number_types.UOffsetTFlags.py_type(nativeInline), 0)
 

tests/MyGame/Example/NestedStruct.cs

@@ -17,12 +17,30 @@ public struct NestedStruct : IFlatbufferObject
   public NestedStruct __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
 
   public int A(int j) { return __p.bb.GetInt(__p.bb_pos + 0 + j * 4); }
+  public const int ALength = 2;
+#if ENABLE_SPAN_T
+  public Span<int> GetABytes() { return System.Runtime.InteropServices.MemoryMarshal.Cast<byte, int>(__p.bb.ToSpan(__p.bb_pos + 0, 8)); }
+#else
+  public ArraySegment<byte>? GetABytes() { return __p.bb.ToArraySegment(__p.bb_pos + 0, 8);}
+#endif
   public void MutateA(int j, int a) { __p.bb.PutInt(__p.bb_pos + 0 + j * 4, a); }
   public MyGame.Example.TestEnum B { get { return (MyGame.Example.TestEnum)__p.bb.GetSbyte(__p.bb_pos + 8); } }
   public void MutateB(MyGame.Example.TestEnum b) { __p.bb.PutSbyte(__p.bb_pos + 8, (sbyte)b); }
   public MyGame.Example.TestEnum C(int j) { return (MyGame.Example.TestEnum)__p.bb.GetSbyte(__p.bb_pos + 9 + j * 1); }
+  public const int CLength = 2;
+#if ENABLE_SPAN_T
+  public Span<MyGame.Example.TestEnum> GetCBytes() { return System.Runtime.InteropServices.MemoryMarshal.Cast<byte, MyGame.Example.TestEnum>(__p.bb.ToSpan(__p.bb_pos + 9, 2)); }
+#else
+  public ArraySegment<byte>? GetCBytes() { return __p.bb.ToArraySegment(__p.bb_pos + 9, 2);}
+#endif
   public void MutateC(int j, MyGame.Example.TestEnum c) { __p.bb.PutSbyte(__p.bb_pos + 9 + j * 1, (sbyte)c); }
   public long D(int j) { return __p.bb.GetLong(__p.bb_pos + 16 + j * 8); }
+  public const int DLength = 2;
+#if ENABLE_SPAN_T
+  public Span<long> GetDBytes() { return System.Runtime.InteropServices.MemoryMarshal.Cast<byte, long>(__p.bb.ToSpan(__p.bb_pos + 16, 16)); }
+#else
+  public ArraySegment<byte>? GetDBytes() { return __p.bb.ToArraySegment(__p.bb_pos + 16, 16);}
+#endif
   public void MutateD(int j, long d) { __p.bb.PutLong(__p.bb_pos + 16 + j * 8, d); }
 
   public static Offset<MyGame.Example.NestedStruct> CreateNestedStruct(FlatBufferBuilder builder, int[] A, MyGame.Example.TestEnum B, MyGame.Example.TestEnum[] C, long[] D) {

tests/MyGame/Example/TypeAliases.py

@@ -230,6 +230,16 @@ def TypeAliasesStartV8Vector(builder, numElems):
 def StartV8Vector(builder, numElems):
     return TypeAliasesStartV8Vector(builder, numElems)
 
+def TypeAliasesCreateV8Vector(builder, data):
+    data = list(data)
+    builder.StartVector(1, len(data), 1)
+    for item in reversed(data):
+        builder.PrependInt8(item)
+    return builder.EndVector()
+
+def CreateV8Vector(builder, data):
+    return TypeAliasesCreateV8Vector(builder, data)
+
 def TypeAliasesAddVf64(builder, vf64):
     builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0)
 
@@ -242,6 +252,16 @@ def TypeAliasesStartVf64Vector(builder, numElems):
 def StartVf64Vector(builder, numElems):
     return TypeAliasesStartVf64Vector(builder, numElems)
 
+def TypeAliasesCreateVf64Vector(builder, data):
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependFloat64(item)
+    return builder.EndVector()
+
+def CreateVf64Vector(builder, data):
+    return TypeAliasesCreateVf64Vector(builder, data)
+
 def TypeAliasesEnd(builder):
     return builder.EndObject()
 

tests/MyGame/MonsterExtra.py

@@ -5,6 +5,7 @@
 import flatbuffers
 from flatbuffers.compat import import_numpy
 from typing import Any
+from typing import Iterable
 np = import_numpy()
 
 class MonsterExtra(object):
@@ -205,6 +206,16 @@ def MonsterExtraStartDvecVector(builder, numElems: int) -> int:
 def StartDvecVector(builder, numElems: int) -> int:
     return MonsterExtraStartDvecVector(builder, numElems)
 
+def MonsterExtraCreateDvecVector(builder: flatbuffers.Builder, data: Iterable[Any]) -> int:
+    data = list(data)
+    builder.StartVector(8, len(data), 8)
+    for item in reversed(data):
+        builder.PrependFloat64(item)
+    return builder.EndVector()
+
+def CreateDvecVector(builder: flatbuffers.Builder, data: Iterable[Any]) -> int:
+    return MonsterExtraCreateDvecVector(builder, data)
+
 def MonsterExtraAddFvec(builder: flatbuffers.Builder, fvec: int):
     builder.PrependUOffsetTRelativeSlot(9, flatbuffers.number_types.UOffsetTFlags.py_type(fvec), 0)
 
@@ -217,6 +228,16 @@ def MonsterExtraStartFvecVector(builder, numElems: int) -> int:
 def StartFvecVector(builder, numElems: int) -> int:
     return MonsterExtraStartFvecVector(builder, numElems)
 
+def MonsterExtraCreateFvecVector(builder: flatbuffers.Builder, data: Iterable[Any]) -> int:
+    data = list(data)
+    builder.StartVector(4, len(data), 4)
+    for item in reversed(data):
+        builder.PrependFloat32(item)
+    return builder.EndVector()
+
+def CreateFvecVector(builder: flatbuffers.Builder, data: Iterable[Any]) -> int:
+    return MonsterExtraCreateFvecVector(builder, data)
+
 def MonsterExtraEnd(builder: flatbuffers.Builder) -> int:
     return builder.EndObject()
 

tests/MyGame/MonsterExtra.pyi

@@ -77,9 +77,13 @@ def MonsterExtraAddF3(builder: flatbuffers.Builder, f3: float) -> None: ...
 def MonsterExtraAddDvec(builder: flatbuffers.Builder, dvec: uoffset) -> None: ...
 def MonsterExtraStartDvecVector(builder: flatbuffers.Builder, num_elems: int) -> uoffset: ...
 def StartDvecVector(builder: flatbuffers.Builder, num_elems: int) -> uoffset: ...
+def MonsterExtraCreateDvecVector(builder: flatbuffers.Builder, data: typing.Iterable[typing.Any]) -> uoffset: ...
+def CreateDvecVector(builder: flatbuffers.Builder, data: typing.Iterable[typing.Any]) -> uoffset: ...
 def MonsterExtraAddFvec(builder: flatbuffers.Builder, fvec: uoffset) -> None: ...
 def MonsterExtraStartFvecVector(builder: flatbuffers.Builder, num_elems: int) -> uoffset: ...
 def StartFvecVector(builder: flatbuffers.Builder, num_elems: int) -> uoffset: ...
+def MonsterExtraCreateFvecVector(builder: flatbuffers.Builder, data: typing.Iterable[typing.Any]) -> uoffset: ...
+def CreateFvecVector(builder: flatbuffers.Builder, data: typing.Iterable[typing.Any]) -> uoffset: ...
 def MonsterExtraEnd(builder: flatbuffers.Builder) -> uoffset: ...
 def End(builder: flatbuffers.Builder) -> uoffset: ...
 

tests/PythonTest.sh

@@ -28,6 +28,7 @@ ${test_dir}/../flatc -p -o ${gen_code_path} -I include_test monster_extra.fbs --
 ${test_dir}/../flatc -p -o ${gen_code_path} -I include_test arrays_test.fbs --gen-object-api --python-typing
 ${test_dir}/../flatc -p -o ${gen_code_path} -I include_test nested_union_test.fbs --gen-object-api --python-typing --python-decode-obj-api-strings
 ${test_dir}/../flatc -p -o ${gen_code_path} -I include_test service_test.fbs --grpc --grpc-python-typed-handlers --python-typing --no-python-gen-numpy --gen-onefile
+${test_dir}/../flatc -p -o ${gen_code_path} union_name_test.fbs --gen-object-api
 
 # Syntax: run_tests <interpreter> <benchmark vtable dedupes>
 #                   <benchmark read count> <benchmark build count>

tests/arrays_test.fbs

@@ -18,6 +18,14 @@ struct ArrayStruct{
   f:[int64:2];
 }
 
+struct LargeArrayStruct {
+  d:[ubyte:64];
+  e:[float:64];
+  f:[bool:64];
+  g:[NestedStruct:64];
+  h:[TestEnum:64];
+}
+
 table ArrayTable{
   a:ArrayStruct;
 }

tests/arrays_test.schema.json

@@ -59,6 +59,37 @@
       },
       "additionalProperties" : false
     },
+    "MyGame_Example_LargeArrayStruct" : {
+      "type" : "object",
+      "properties" : {
+        "d" : {
+                "type" : "array", "items" : {"type" : "integer", "minimum" : 0, "maximum" :255},
+                "minItems": 64,
+                "maxItems": 64
+              },
+        "e" : {
+                "type" : "array", "items" : {"type" : "number"},
+                "minItems": 64,
+                "maxItems": 64
+              },
+        "f" : {
+                "type" : "array", "items" : {"type" : "boolean"},
+                "minItems": 64,
+                "maxItems": 64
+              },
+        "g" : {
+                "type" : "array", "items" : {"$ref" : "#/definitions/MyGame_Example_NestedStruct"},
+                "minItems": 64,
+                "maxItems": 64
+              },
+        "h" : {
+                "type" : "array", "items" : {"$ref" : "#/definitions/MyGame_Example_TestEnum"},
+                "minItems": 64,
+                "maxItems": 64
+              }
+      },
+      "additionalProperties" : false
+    },
     "MyGame_Example_ArrayTable" : {
       "type" : "object",
       "properties" : {

tests/arrays_test/arrays_test_generated.rs

@@ -0,0 +1,921 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// @generated
+
+extern crate alloc;
+
+#[allow(unused_imports, dead_code)]
+pub mod my_game {
+
+extern crate alloc;
+#[allow(unused_imports, dead_code)]
+pub mod example {
+
+extern crate alloc;
+
+#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
+pub const ENUM_MIN_TEST_ENUM: i8 = 0;
+#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
+pub const ENUM_MAX_TEST_ENUM: i8 = 2;
+#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
+#[allow(non_camel_case_types)]
+pub const ENUM_VALUES_TEST_ENUM: [TestEnum; 3] = [
+  TestEnum::A,
+  TestEnum::B,
+  TestEnum::C,
+];
+
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+#[repr(transparent)]
+pub struct TestEnum(pub i8);
+#[allow(non_upper_case_globals)]
+impl TestEnum {
+  pub const A: Self = Self(0);
+  pub const B: Self = Self(1);
+  pub const C: Self = Self(2);
+
+  pub const ENUM_MIN: i8 = 0;
+  pub const ENUM_MAX: i8 = 2;
+  pub const ENUM_VALUES: &'static [Self] = &[
+    Self::A,
+    Self::B,
+    Self::C,
+  ];
+  /// Returns the variant's name or "" if unknown.
+  pub fn variant_name(self) -> Option<&'static str> {
+    match self {
+      Self::A => Some("A"),
+      Self::B => Some("B"),
+      Self::C => Some("C"),
+      _ => None,
+    }
+  }
+}
+impl ::core::fmt::Debug for TestEnum {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    if let Some(name) = self.variant_name() {
+      f.write_str(name)
+    } else {
+      f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
+    }
+  }
+}
+impl<'a> ::flatbuffers::Follow<'a> for TestEnum {
+  type Inner = Self;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    let b = unsafe { ::flatbuffers::read_scalar_at::<i8>(buf, loc) };
+    Self(b)
+  }
+}
+
+impl ::flatbuffers::Push for TestEnum {
+    type Output = TestEnum;
+    #[inline]
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        unsafe { ::flatbuffers::emplace_scalar::<i8>(dst, self.0) };
+    }
+}
+
+impl ::flatbuffers::EndianScalar for TestEnum {
+  type Scalar = i8;
+  #[inline]
+  fn to_little_endian(self) -> i8 {
+    self.0.to_le()
+  }
+  #[inline]
+  #[allow(clippy::wrong_self_convention)]
+  fn from_little_endian(v: i8) -> Self {
+    let b = i8::from_le(v);
+    Self(b)
+  }
+}
+
+impl<'a> ::flatbuffers::Verifiable for TestEnum {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    i8::run_verifier(v, pos)
+  }
+}
+
+impl ::flatbuffers::SimpleToVerifyInSlice for TestEnum {}
+// struct NestedStruct, aligned to 8
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq)]
+pub struct NestedStruct(pub [u8; 32]);
+impl Default for NestedStruct { 
+  fn default() -> Self { 
+    Self([0; 32])
+  }
+}
+impl ::core::fmt::Debug for NestedStruct {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    f.debug_struct("NestedStruct")
+      .field("a", &self.a())
+      .field("b", &self.b())
+      .field("c", &self.c())
+      .field("d", &self.d())
+      .finish()
+  }
+}
+
+impl ::flatbuffers::SimpleToVerifyInSlice for NestedStruct {}
+impl<'a> ::flatbuffers::Follow<'a> for NestedStruct {
+  type Inner = &'a NestedStruct;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe { <&'a NestedStruct>::follow(buf, loc) }
+  }
+}
+impl<'a> ::flatbuffers::Follow<'a> for &'a NestedStruct {
+  type Inner = &'a NestedStruct;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe { ::flatbuffers::follow_cast_ref::<NestedStruct>(buf, loc) }
+  }
+}
+impl<'b> ::flatbuffers::Push for NestedStruct {
+    type Output = NestedStruct;
+    #[inline]
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        let src = unsafe { ::core::slice::from_raw_parts(self as *const NestedStruct as *const u8, <Self as ::flatbuffers::Push>::size()) };
+        dst.copy_from_slice(src);
+    }
+    #[inline]
+    fn alignment() -> ::flatbuffers::PushAlignment {
+        ::flatbuffers::PushAlignment::new(8)
+    }
+}
+
+impl<'a> ::flatbuffers::Verifiable for NestedStruct {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.in_buffer::<Self>(pos)
+  }
+}
+
+impl<'a> NestedStruct {
+  #[allow(clippy::too_many_arguments)]
+  pub fn new(
+    a: &[i32; 2],
+    b: TestEnum,
+    c: &[TestEnum; 2],
+    d: &[i64; 2],
+  ) -> Self {
+    let mut s = Self([0; 32]);
+    s.set_a(a);
+    s.set_b(b);
+    s.set_c(c);
+    s.set_d(d);
+    s
+  }
+
+  pub fn a(&'a self) -> ::flatbuffers::Array<'a, i32, 2> {
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid array in this slot
+    use ::flatbuffers::Follow;
+    unsafe { ::flatbuffers::Array::follow(&self.0, 0) }
+  }
+
+  pub fn set_a(&mut self, items: &[i32; 2]) {
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid array in this slot
+    unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 0, items) };
+  }
+
+  pub fn b(&self) -> TestEnum {
+    let mut mem = ::core::mem::MaybeUninit::<<TestEnum as ::flatbuffers::EndianScalar>::Scalar>::uninit();
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid value in this slot
+    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
+      ::core::ptr::copy_nonoverlapping(
+        self.0[8..].as_ptr(),
+        mem.as_mut_ptr() as *mut u8,
+        ::core::mem::size_of::<<TestEnum as ::flatbuffers::EndianScalar>::Scalar>(),
+      );
+      mem.assume_init()
+    })
+  }
+
+  pub fn set_b(&mut self, x: TestEnum) {
+    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid value in this slot
+    unsafe {
+      ::core::ptr::copy_nonoverlapping(
+        &x_le as *const _ as *const u8,
+        self.0[8..].as_mut_ptr(),
+        ::core::mem::size_of::<<TestEnum as ::flatbuffers::EndianScalar>::Scalar>(),
+      );
+    }
+  }
+
+  pub fn c(&'a self) -> ::flatbuffers::Array<'a, TestEnum, 2> {
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid array in this slot
+    use ::flatbuffers::Follow;
+    unsafe { ::flatbuffers::Array::follow(&self.0, 9) }
+  }
+
+  pub fn set_c(&mut self, x: &[TestEnum; 2]) {
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid array in this slot
+    unsafe {
+      ::core::ptr::copy(
+        x.as_ptr() as *const u8,
+        self.0.as_mut_ptr().add(9),
+        2,
+      );
+    }
+  }
+
+  pub fn d(&'a self) -> ::flatbuffers::Array<'a, i64, 2> {
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid array in this slot
+    use ::flatbuffers::Follow;
+    unsafe { ::flatbuffers::Array::follow(&self.0, 16) }
+  }
+
+  pub fn set_d(&mut self, items: &[i64; 2]) {
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid array in this slot
+    unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 16, items) };
+  }
+
+  pub fn unpack(&self) -> NestedStructT {
+    NestedStructT {
+      a: self.a().into(),
+      b: self.b(),
+      c: self.c().into(),
+      d: self.d().into(),
+    }
+  }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct NestedStructT {
+  pub a: [i32; 2],
+  pub b: TestEnum,
+  pub c: [TestEnum; 2],
+  pub d: [i64; 2],
+}
+impl Default for NestedStructT {
+  fn default() -> Self {
+    Self {
+      a: [0; 2],
+      b: TestEnum::A,
+      c: ::flatbuffers::array_init(|_| Default::default()),
+      d: [0; 2],
+    }
+  }
+}
+impl NestedStructT {
+  pub fn pack(&self) -> NestedStruct {
+    NestedStruct::new(
+      &self.a,
+      self.b,
+      &self.c,
+      &self.d,
+    )
+  }
+}
+
+// struct ArrayStruct, aligned to 8
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq)]
+pub struct ArrayStruct(pub [u8; 160]);
+impl Default for ArrayStruct { 
+  fn default() -> Self { 
+    Self([0; 160])
+  }
+}
+impl ::core::fmt::Debug for ArrayStruct {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    f.debug_struct("ArrayStruct")
+      .field("a", &self.a())
+      .field("b", &self.b())
+      .field("c", &self.c())
+      .field("d", &self.d())
+      .field("e", &self.e())
+      .field("f", &self.f())
+      .finish()
+  }
+}
+
+impl ::flatbuffers::SimpleToVerifyInSlice for ArrayStruct {}
+impl<'a> ::flatbuffers::Follow<'a> for ArrayStruct {
+  type Inner = &'a ArrayStruct;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe { <&'a ArrayStruct>::follow(buf, loc) }
+  }
+}
+impl<'a> ::flatbuffers::Follow<'a> for &'a ArrayStruct {
+  type Inner = &'a ArrayStruct;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe { ::flatbuffers::follow_cast_ref::<ArrayStruct>(buf, loc) }
+  }
+}
+impl<'b> ::flatbuffers::Push for ArrayStruct {
+    type Output = ArrayStruct;
+    #[inline]
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        let src = unsafe { ::core::slice::from_raw_parts(self as *const ArrayStruct as *const u8, <Self as ::flatbuffers::Push>::size()) };
+        dst.copy_from_slice(src);
+    }
+    #[inline]
+    fn alignment() -> ::flatbuffers::PushAlignment {
+        ::flatbuffers::PushAlignment::new(8)
+    }
+}
+
+impl<'a> ::flatbuffers::Verifiable for ArrayStruct {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.in_buffer::<Self>(pos)
+  }
+}
+
+impl<'a> ArrayStruct {
+  #[allow(clippy::too_many_arguments)]
+  pub fn new(
+    a: f32,
+    b: &[i32; 15],
+    c: i8,
+    d: &[NestedStruct; 2],
+    e: i32,
+    f: &[i64; 2],
+  ) -> Self {
+    let mut s = Self([0; 160]);
+    s.set_a(a);
+    s.set_b(b);
+    s.set_c(c);
+    s.set_d(d);
+    s.set_e(e);
+    s.set_f(f);
+    s
+  }
+
+  pub fn a(&self) -> f32 {
+    let mut mem = ::core::mem::MaybeUninit::<<f32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid value in this slot
+    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
+      ::core::ptr::copy_nonoverlapping(
+        self.0[0..].as_ptr(),
+        mem.as_mut_ptr() as *mut u8,
+        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
+      );
+      mem.assume_init()
+    })
+  }
+
+  pub fn set_a(&mut self, x: f32) {
+    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid value in this slot
+    unsafe {
+      ::core::ptr::copy_nonoverlapping(
+        &x_le as *const _ as *const u8,
+        self.0[0..].as_mut_ptr(),
+        ::core::mem::size_of::<<f32 as ::flatbuffers::EndianScalar>::Scalar>(),
+      );
+    }
+  }
+
+  pub fn b(&'a self) -> ::flatbuffers::Array<'a, i32, 15> {
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid array in this slot
+    use ::flatbuffers::Follow;
+    unsafe { ::flatbuffers::Array::follow(&self.0, 4) }
+  }
+
+  pub fn set_b(&mut self, items: &[i32; 15]) {
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid array in this slot
+    unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 4, items) };
+  }
+
+  pub fn c(&self) -> i8 {
+    let mut mem = ::core::mem::MaybeUninit::<<i8 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid value in this slot
+    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
+      ::core::ptr::copy_nonoverlapping(
+        self.0[64..].as_ptr(),
+        mem.as_mut_ptr() as *mut u8,
+        ::core::mem::size_of::<<i8 as ::flatbuffers::EndianScalar>::Scalar>(),
+      );
+      mem.assume_init()
+    })
+  }
+
+  pub fn set_c(&mut self, x: i8) {
+    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid value in this slot
+    unsafe {
+      ::core::ptr::copy_nonoverlapping(
+        &x_le as *const _ as *const u8,
+        self.0[64..].as_mut_ptr(),
+        ::core::mem::size_of::<<i8 as ::flatbuffers::EndianScalar>::Scalar>(),
+      );
+    }
+  }
+
+  pub fn d(&'a self) -> ::flatbuffers::Array<'a, NestedStruct, 2> {
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid array in this slot
+    use ::flatbuffers::Follow;
+    unsafe { ::flatbuffers::Array::follow(&self.0, 72) }
+  }
+
+  pub fn set_d(&mut self, x: &[NestedStruct; 2]) {
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid array in this slot
+    unsafe {
+      ::core::ptr::copy(
+        x.as_ptr() as *const u8,
+        self.0.as_mut_ptr().add(72),
+        64,
+      );
+    }
+  }
+
+  pub fn e(&self) -> i32 {
+    let mut mem = ::core::mem::MaybeUninit::<<i32 as ::flatbuffers::EndianScalar>::Scalar>::uninit();
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid value in this slot
+    ::flatbuffers::EndianScalar::from_little_endian(unsafe {
+      ::core::ptr::copy_nonoverlapping(
+        self.0[136..].as_ptr(),
+        mem.as_mut_ptr() as *mut u8,
+        ::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
+      );
+      mem.assume_init()
+    })
+  }
+
+  pub fn set_e(&mut self, x: i32) {
+    let x_le = ::flatbuffers::EndianScalar::to_little_endian(x);
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid value in this slot
+    unsafe {
+      ::core::ptr::copy_nonoverlapping(
+        &x_le as *const _ as *const u8,
+        self.0[136..].as_mut_ptr(),
+        ::core::mem::size_of::<<i32 as ::flatbuffers::EndianScalar>::Scalar>(),
+      );
+    }
+  }
+
+  pub fn f(&'a self) -> ::flatbuffers::Array<'a, i64, 2> {
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid array in this slot
+    use ::flatbuffers::Follow;
+    unsafe { ::flatbuffers::Array::follow(&self.0, 144) }
+  }
+
+  pub fn set_f(&mut self, items: &[i64; 2]) {
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid array in this slot
+    unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 144, items) };
+  }
+
+  pub fn unpack(&self) -> ArrayStructT {
+    ArrayStructT {
+      a: self.a(),
+      b: self.b().into(),
+      c: self.c(),
+      d: { let d = self.d(); ::flatbuffers::array_init(|i| d.get(i).unpack()) },
+      e: self.e(),
+      f: self.f().into(),
+    }
+  }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct ArrayStructT {
+  pub a: f32,
+  pub b: [i32; 15],
+  pub c: i8,
+  pub d: [NestedStructT; 2],
+  pub e: i32,
+  pub f: [i64; 2],
+}
+impl Default for ArrayStructT {
+  fn default() -> Self {
+    Self {
+      a: 0.0,
+      b: [0; 15],
+      c: 0,
+      d: ::flatbuffers::array_init(|_| Default::default()),
+      e: 0,
+      f: [0; 2],
+    }
+  }
+}
+impl ArrayStructT {
+  pub fn pack(&self) -> ArrayStruct {
+    ArrayStruct::new(
+      self.a,
+      &self.b,
+      self.c,
+      &::flatbuffers::array_init(|i| self.d[i].pack()),
+      self.e,
+      &self.f,
+    )
+  }
+}
+
+// struct LargeArrayStruct, aligned to 4
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq)]
+pub struct LargeArrayStruct(pub [u8; 384]);
+impl Default for LargeArrayStruct { 
+  fn default() -> Self { 
+    Self([0; 384])
+  }
+}
+impl ::core::fmt::Debug for LargeArrayStruct {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+    f.debug_struct("LargeArrayStruct")
+      .field("d", &self.d())
+      .field("e", &self.e())
+      .field("f", &self.f())
+      .finish()
+  }
+}
+
+impl ::flatbuffers::SimpleToVerifyInSlice for LargeArrayStruct {}
+impl<'a> ::flatbuffers::Follow<'a> for LargeArrayStruct {
+  type Inner = &'a LargeArrayStruct;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe { <&'a LargeArrayStruct>::follow(buf, loc) }
+  }
+}
+impl<'a> ::flatbuffers::Follow<'a> for &'a LargeArrayStruct {
+  type Inner = &'a LargeArrayStruct;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe { ::flatbuffers::follow_cast_ref::<LargeArrayStruct>(buf, loc) }
+  }
+}
+impl<'b> ::flatbuffers::Push for LargeArrayStruct {
+    type Output = LargeArrayStruct;
+    #[inline]
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        let src = unsafe { ::core::slice::from_raw_parts(self as *const LargeArrayStruct as *const u8, <Self as ::flatbuffers::Push>::size()) };
+        dst.copy_from_slice(src);
+    }
+    #[inline]
+    fn alignment() -> ::flatbuffers::PushAlignment {
+        ::flatbuffers::PushAlignment::new(4)
+    }
+}
+
+impl<'a> ::flatbuffers::Verifiable for LargeArrayStruct {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.in_buffer::<Self>(pos)
+  }
+}
+
+impl<'a> LargeArrayStruct {
+  #[allow(clippy::too_many_arguments)]
+  pub fn new(
+    d: &[u8; 64],
+    e: &[f32; 64],
+    f: &[bool; 64],
+  ) -> Self {
+    let mut s = Self([0; 384]);
+    s.set_d(d);
+    s.set_e(e);
+    s.set_f(f);
+    s
+  }
+
+  pub fn d(&'a self) -> ::flatbuffers::Array<'a, u8, 64> {
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid array in this slot
+    use ::flatbuffers::Follow;
+    unsafe { ::flatbuffers::Array::follow(&self.0, 0) }
+  }
+
+  pub fn set_d(&mut self, items: &[u8; 64]) {
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid array in this slot
+    unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 0, items) };
+  }
+
+  pub fn e(&'a self) -> ::flatbuffers::Array<'a, f32, 64> {
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid array in this slot
+    use ::flatbuffers::Follow;
+    unsafe { ::flatbuffers::Array::follow(&self.0, 64) }
+  }
+
+  pub fn set_e(&mut self, items: &[f32; 64]) {
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid array in this slot
+    unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 64, items) };
+  }
+
+  pub fn f(&'a self) -> ::flatbuffers::Array<'a, bool, 64> {
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid array in this slot
+    use ::flatbuffers::Follow;
+    unsafe { ::flatbuffers::Array::follow(&self.0, 320) }
+  }
+
+  pub fn set_f(&mut self, items: &[bool; 64]) {
+    // Safety:
+    // Created from a valid Table for this object
+    // Which contains a valid array in this slot
+    unsafe { ::flatbuffers::emplace_scalar_array(&mut self.0, 320, items) };
+  }
+
+  pub fn unpack(&self) -> LargeArrayStructT {
+    LargeArrayStructT {
+      d: self.d().into(),
+      e: self.e().into(),
+      f: self.f().into(),
+    }
+  }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct LargeArrayStructT {
+  pub d: [u8; 64],
+  pub e: [f32; 64],
+  pub f: [bool; 64],
+}
+impl Default for LargeArrayStructT {
+  fn default() -> Self {
+    Self {
+      d: [0; 64],
+      e: [0.0; 64],
+      f: [false; 64],
+    }
+  }
+}
+impl LargeArrayStructT {
+  pub fn pack(&self) -> LargeArrayStruct {
+    LargeArrayStruct::new(
+      &self.d,
+      &self.e,
+      &self.f,
+    )
+  }
+}
+
+pub enum ArrayTableOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct ArrayTable<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for ArrayTable<'a> {
+  type Inner = ArrayTable<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> ArrayTable<'a> {
+  pub const VT_A: ::flatbuffers::VOffsetT = 4;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    ArrayTable { _tab: table }
+  }
+  #[allow(unused_mut)]
+  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr, A: ::flatbuffers::Allocator + 'bldr>(
+    _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
+    args: &'args ArrayTableArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<ArrayTable<'bldr>> {
+    let mut builder = ArrayTableBuilder::new(_fbb);
+    if let Some(x) = args.a { builder.add_a(x); }
+    builder.finish()
+  }
+
+  pub fn unpack(&self) -> ArrayTableT {
+    let a = self.a().map(|x| {
+      x.unpack()
+    });
+    ArrayTableT {
+      a,
+    }
+  }
+
+  #[inline]
+  pub fn a(&self) -> Option<&'a ArrayStruct> {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<ArrayStruct>(ArrayTable::VT_A, None)}
+  }
+}
+
+impl ::flatbuffers::Verifiable for ArrayTable<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<ArrayStruct>("a", Self::VT_A, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct ArrayTableArgs<'a> {
+    pub a: Option<&'a ArrayStruct>,
+}
+impl<'a> Default for ArrayTableArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    ArrayTableArgs {
+      a: None,
+    }
+  }
+}
+
+pub struct ArrayTableBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
+  fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+  start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
+}
+impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ArrayTableBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_a(&mut self, a: &ArrayStruct) {
+    self.fbb_.push_slot_always::<&ArrayStruct>(ArrayTable::VT_A, a);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ArrayTableBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    ArrayTableBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<ArrayTable<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for ArrayTable<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("ArrayTable");
+      ds.field("a", &self.a());
+      ds.finish()
+  }
+}
+#[non_exhaustive]
+#[derive(Debug, Clone, PartialEq)]
+pub struct ArrayTableT {
+  pub a: Option<ArrayStructT>,
+}
+impl Default for ArrayTableT {
+  fn default() -> Self {
+    Self {
+      a: None,
+    }
+  }
+}
+impl ArrayTableT {
+  pub fn pack<'b, A: ::flatbuffers::Allocator + 'b>(
+    &self,
+    _fbb: &mut ::flatbuffers::FlatBufferBuilder<'b, A>
+  ) -> ::flatbuffers::WIPOffset<ArrayTable<'b>> {
+    let a_tmp = self.a.as_ref().map(|x| x.pack());
+    let a = a_tmp.as_ref();
+    ArrayTable::create(_fbb, &ArrayTableArgs{
+      a,
+    })
+  }
+}
+#[inline]
+/// Verifies that a buffer of bytes contains a `ArrayTable`
+/// and returns it.
+/// Note that verification is still experimental and may not
+/// catch every error, or be maximally performant. For the
+/// previous, unchecked, behavior use
+/// `root_as_array_table_unchecked`.
+pub fn root_as_array_table(buf: &[u8]) -> Result<ArrayTable<'_>, ::flatbuffers::InvalidFlatbuffer> {
+  ::flatbuffers::root::<ArrayTable>(buf)
+}
+#[inline]
+/// Verifies that a buffer of bytes contains a size prefixed
+/// `ArrayTable` and returns it.
+/// Note that verification is still experimental and may not
+/// catch every error, or be maximally performant. For the
+/// previous, unchecked, behavior use
+/// `size_prefixed_root_as_array_table_unchecked`.
+pub fn size_prefixed_root_as_array_table(buf: &[u8]) -> Result<ArrayTable<'_>, ::flatbuffers::InvalidFlatbuffer> {
+  ::flatbuffers::size_prefixed_root::<ArrayTable>(buf)
+}
+#[inline]
+/// Verifies, with the given options, that a buffer of bytes
+/// contains a `ArrayTable` and returns it.
+/// Note that verification is still experimental and may not
+/// catch every error, or be maximally performant. For the
+/// previous, unchecked, behavior use
+/// `root_as_array_table_unchecked`.
+pub fn root_as_array_table_with_opts<'b, 'o>(
+  opts: &'o ::flatbuffers::VerifierOptions,
+  buf: &'b [u8],
+) -> Result<ArrayTable<'b>, ::flatbuffers::InvalidFlatbuffer> {
+  ::flatbuffers::root_with_opts::<ArrayTable<'b>>(opts, buf)
+}
+#[inline]
+/// Verifies, with the given verifier options, that a buffer of
+/// bytes contains a size prefixed `ArrayTable` and returns
+/// it. Note that verification is still experimental and may not
+/// catch every error, or be maximally performant. For the
+/// previous, unchecked, behavior use
+/// `root_as_array_table_unchecked`.
+pub fn size_prefixed_root_as_array_table_with_opts<'b, 'o>(
+  opts: &'o ::flatbuffers::VerifierOptions,
+  buf: &'b [u8],
+) -> Result<ArrayTable<'b>, ::flatbuffers::InvalidFlatbuffer> {
+  ::flatbuffers::size_prefixed_root_with_opts::<ArrayTable<'b>>(opts, buf)
+}
+#[inline]
+/// Assumes, without verification, that a buffer of bytes contains a ArrayTable and returns it.
+/// # Safety
+/// Callers must trust the given bytes do indeed contain a valid `ArrayTable`.
+pub unsafe fn root_as_array_table_unchecked(buf: &[u8]) -> ArrayTable<'_> {
+  unsafe { ::flatbuffers::root_unchecked::<ArrayTable>(buf) }
+}
+#[inline]
+/// Assumes, without verification, that a buffer of bytes contains a size prefixed ArrayTable and returns it.
+/// # Safety
+/// Callers must trust the given bytes do indeed contain a valid size prefixed `ArrayTable`.
+pub unsafe fn size_prefixed_root_as_array_table_unchecked(buf: &[u8]) -> ArrayTable<'_> {
+  unsafe { ::flatbuffers::size_prefixed_root_unchecked::<ArrayTable>(buf) }
+}
+pub const ARRAY_TABLE_IDENTIFIER: &str = "ARRT";
+
+#[inline]
+pub fn array_table_buffer_has_identifier(buf: &[u8]) -> bool {
+  ::flatbuffers::buffer_has_identifier(buf, ARRAY_TABLE_IDENTIFIER, false)
+}
+
+#[inline]
+pub fn array_table_size_prefixed_buffer_has_identifier(buf: &[u8]) -> bool {
+  ::flatbuffers::buffer_has_identifier(buf, ARRAY_TABLE_IDENTIFIER, true)
+}
+
+pub const ARRAY_TABLE_EXTENSION: &str = "mon";
+
+#[inline]
+pub fn finish_array_table_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
+    fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
+    root: ::flatbuffers::WIPOffset<ArrayTable<'a>>) {
+  fbb.finish(root, Some(ARRAY_TABLE_IDENTIFIER));
+}
+
+#[inline]
+pub fn finish_size_prefixed_array_table_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>, root: ::flatbuffers::WIPOffset<ArrayTable<'a>>) {
+  fbb.finish_size_prefixed(root, Some(ARRAY_TABLE_IDENTIFIER));
+}
+}  // pub mod Example
+}  // pub mod MyGame
+

tests/arrays_test/mod.rs

@@ -10,6 +10,8 @@ pub mod my_game {
         pub use self::nested_struct_generated::*;
         mod array_struct_generated;
         pub use self::array_struct_generated::*;
+        mod large_array_struct_generated;
+        pub use self::large_array_struct_generated::*;
         mod array_table_generated;
         pub use self::array_table_generated::*;
     } // example

tests/arrays_test/my_game/example/array_struct_generated.rs

@@ -2,15 +2,18 @@
 // @generated
 extern crate alloc;
 use super::*;
+
 // struct ArrayStruct, aligned to 8
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq)]
 pub struct ArrayStruct(pub [u8; 160]);
+
 impl Default for ArrayStruct {
     fn default() -> Self {
         Self([0; 160])
     }
 }
+
 impl ::core::fmt::Debug for ArrayStruct {
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
         f.debug_struct("ArrayStruct")
@@ -25,27 +28,34 @@ impl ::core::fmt::Debug for ArrayStruct {
 }
 
 impl ::flatbuffers::SimpleToVerifyInSlice for ArrayStruct {}
+
 impl<'a> ::flatbuffers::Follow<'a> for ArrayStruct {
     type Inner = &'a ArrayStruct;
+
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         unsafe { <&'a ArrayStruct>::follow(buf, loc) }
     }
 }
+
 impl<'a> ::flatbuffers::Follow<'a> for &'a ArrayStruct {
     type Inner = &'a ArrayStruct;
+
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         unsafe { ::flatbuffers::follow_cast_ref::<ArrayStruct>(buf, loc) }
     }
 }
+
 impl<'b> ::flatbuffers::Push for ArrayStruct {
     type Output = ArrayStruct;
+
     #[inline]
     unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
         let src = unsafe { ::core::slice::from_raw_parts(self as *const ArrayStruct as *const u8, <Self as ::flatbuffers::Push>::size()) };
         dst.copy_from_slice(src);
     }
+
     #[inline]
     fn alignment() -> ::flatbuffers::PushAlignment {
         ::flatbuffers::PushAlignment::new(8)
@@ -235,7 +245,7 @@ impl<'a> ArrayStruct {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Default)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct ArrayStructT {
     pub a: f32,
     pub b: [i32; 15],
@@ -244,6 +254,19 @@ pub struct ArrayStructT {
     pub e: i32,
     pub f: [i64; 2],
 }
+impl Default for ArrayStructT {
+    fn default() -> Self {
+        Self {
+            a: 0.0,
+            b: [0; 15],
+            c: 0,
+            d: ::flatbuffers::array_init(|_| Default::default()),
+            e: 0,
+            f: [0; 2],
+        }
+    }
+}
+
 impl ArrayStructT {
     pub fn pack(&self) -> ArrayStruct {
         ArrayStruct::new(
@@ -256,4 +279,3 @@ impl ArrayStructT {
         )
     }
 }
-